Documentation

Constructs a CodeExpr representing the field of an actor

Basic chunk representation in the code generation context. Contains a DefinedQuantityDict and the kind of code (variable or function).

Chunk representing a variable. The obv field represents the object containing this variable, if it is an object field.

Chunk representing a function.

Construct a CodeVarChunk from a Quantity.

Construct a CodeFuncChunk from a Quantity.

Initializes the generator's DrasilState. String parameter is a string representing the date. \['Expr'\] parameter is the sample input values provided by the user.

Generates a package with the given DrasilState. The passed un-representation functions determine which target language the package will be generated in.

Generates a package with the given DrasilState. The passed un-representation functions determine which target language the package will be generated in.

Internal: Converts a list of FileData to a FileLayout.

Reads data from a file and converts the values to Exprs. The file must be formatted according to the DataDesc' passed as a parameter.

Defines the DataDesc for the file containing a sample data set, which a user must supply if they want to generate a sample input file.

Constructor for a single datum.

Constructor for junk data.

Constructor for an unknown amount of lines of data.

Constructor for data with a repeated pattern.

Constructor for a single line of data.

An argument may contain a named argument and argument information.

Specifies an implementation of an interface from the external library.

A step can be a call to an external library function or method.

External library is a group of Steps

The first item in the Requires list should be where the function being called is defined.

Specifies an external library.

To be used when there are multiple options for a group of consecutive steps, where a single use-case-specific factor decides which step group to use.

To be used when there are multiple options for a single step, where a use-case-specific factor decides which step to use.

Specifies a step which must exist in some form in every use case.

Specifies multiple consecutive steps that all must exist in some form in every use case.

Specifies a call to an external library function.

Specifies a call to an external library method.

Specifies a call to an external library function, where the result is assigned to a variable.

Specifies a call to an external library method, where the result is assigned to a variable.

Specifies a call to an external library constructor, where the result is assigned to a variable.

Specifies a call to an external library function, where multiple modules from the external library are required, and the result is assigned to a variable.

Specifies a call to an external library constructor, where the result is returned.

Specifies an argument that is not use-case-dependent.

Specifies a named argument that is not use-case-dependent.

Specifies a use-case-dependent argument whose value can be inlined in the call.

Specifies a use-case-dependent named argument whose value can be inlined in the call.

Specifies use-case-dependent argument whose value must be assigned to a variable before being passed in the call.

Specifies use-case-dependent named argument whose value must be assigned to a variable before being passed in the call.

Specifies a function type argument, where the body consists of a single step.

Specifies an argument that is an object of a class that must be defined in the calling program.

Specifies an argument that is an object of a class from the external library. The list of [CodeVarChunk] represents fields of the object that must be set in the calling program.

Specifies a use-case-independent parameter.

Specifies a parameter whose name depends on the use case.

Specifies a class that must be implemented in the calling program.

Specifies a constructor.

Specifies a method.

Specifies a method that does not return anything.

Specifies a statement where a current solution is appended to a solution list.

Specifies a statement where a solution list is populated by iterating through a solution array.

Specifies statements where every index of an array is assigned a value.

Specifies a statement where a solution is assigned from the field of an object.

Specifies a statement where a solution list is initialized with the first value of an array.

Specifies a statement where a solution list is initialized with the given value.

A solve and populate loop. FunctionInterface for loop condition, CodeChunk for solution object, CodeChunk for independent var, FunctionInterface for solving, CodeChunk for soln array to populate with.

Specifies a statement where a list is returned, where each value of the list is explicitly defined.

Specifies a use-case-independent statement that returns a fixed value.

Specifies a use-case-dependent statement that returns a non-fixed value.

Specifies a statement where a single solution is initialized with a value.

External library call holds a group of step groups.

Holds a group of steps (StepFills). The Int is to "choose" from the options in ExternalLibrary.

Mirrors ExternalLibrary's Step. A StepFill can be a call to an external library function or method.

Mirrors ExternalLibrary's FunctionInterface.

Mirrors ExternalLibrary's ArgumentInfo. Determines the context needed for an argument to work.

Mirrors ExternalLibrary's Parameter.

Mirrors ExternalLibrary's ClassInfo.

Mirrors ExternalLibrary's MethodInfo.

Constructs an ExternalLibraryCall specification.

Corresponds to ExternalLibrary's choiceSteps. Provides the index of the steps that should be used for the current use case.

Corresponds to ExternalLibrary's choiceStep. Provides the index of the step that should be used for the current use case.

Corresponds to ExternalLibrary's mandatorySteps.

Corresponds to ExternalLibrary's mandatoryStep.

Corresponds to ExternalLibrary's callStep.

Corresponds to any of ExternalLibrary's FunctionInterface constructors.

Does not correspond to anything in ExternalLibrary. To be used when the presence of an argument is only a consequence of the use case.

Corresponds to ExternalLibrary's inlineArg, inlineNamedArg, preDefinedArg, and preDefinedNamedArg. Provides the CodeExpr for the argument's value.

Corresponds to ExternalLibrary's functionArg.

Corresponds to ExternalLibrary's customObjArg. Provides the list of state variables for the class that must be written in the calling program.

Corresponds to ExternalLibrary's recordArg. Provides the list of CodeExprs for the values of the fields that must be set by the calling program.

Corresponds to ExternalLibrary's unnamedParam. Provides the CodeVarChunk representing the parameter.

Corresponds to ExternalLibrary's unnamedParam. Provides the CodeVarChunk representing the parameter. Specifies that the parameter is passed by value.

Does not correspond to anything in ExternalLibrary. To be used when the presence of a parameter is only a consequence of the use case.

Corresponds to ExternalLibrary's customClass.

Corresponds to ExternalLibrary's implementation.

Corresponds to ExternalLibrary's constructorInfo. Provides Variable-Value pairs for variables initialized by the constructor.

Corresponds to ExternalLibrary's methodInfo.

Corresponds to ExternalLibrary's appendCurrSol. Provides the CodeVarChunk for the solution list.

Corresponds to ExternalLibrary's populateSolList. Provides the CodeVarChunk for the solution list.

Corresponds to ExternalLibrary's assignArrayIndex. Provides the CodeVarChunk for the array variable. Provides the CodeExprs for the values to assign to each array index.

Corresponds to ExternalLibrary's assignSolFromObj. Provides the CodeVarChunk for the variable that the solution should be assigned to.

Corresponds to ExternalLibrary's initSolListFromArray. Provides the CodeVarChunk for the solution list.

Corresponds to ExternalLibrary's initSolListWithVal. Provides the CodeVarChunk for the solution list and the CodeExpr for the initial element of the solution list

Corresponds to ExternalLibrary's solveAndPopulateWhile. Provides the CodeExpr for the upper bound in the while loop condition and the CodeVarChunk for the solution list.

Corresponds to ExternalLibrary's returnExprList. Provides the list of CodeExprs to return.

Corresponds to ExternalLibrary's fixedReturn. No parameters because the statement is not use-case-dependent.

Corresponds to ExternalLibrary's fixedReturn'. use-case-specific a CodeExpr that parameterize the statement.

Corresponds to ExternalLibrary's initSolWithVal. Provides the CodeVarChunk for one solution and one CodeExpr for the initial element of the solution list

Various OO languages where code may be generated.

Doxygen date-field visibility options.

Options for representing constants in a program.

Constraint behaviour options within program.

Program implementation options.

External Library Options

Doxygen file verbosity options.

Constants options.

The instruction indicates how the generated program should be written down. Full details of Choices documentation https://github.com/JacquesCarette/Drasil/wiki/The-Code-Generator

Comment implementation options.

Logging options for function calls and variable assignments. Eq instances required for Logging and Comments because generator needs to check membership of these elements in lists

Modularity of a program.

Variable structure options.

Code concepts. For now, just pi.

Builds a ConceptMatchMap from an association list of chunks and CodeConcepts.

Specifies which CodeType should be used to represent each mathematical Space. [CodeType] is preferentially-ordered, first CodeType that does not conflict with other choices will be selected.

Builds a SpaceMatch from an association list of Spaces and CodeTypes.

Currently we only support two kind of auxiliary files: sample input file, readme. To generate a sample input file compatible with the generated program, FilePath is the path to the user-provided file containing a sample set of input data.

Gets the file path to a sample input data set from a Choices structure, if the user chose to generate a sample input file.

Default choices to be used as the base from which design specifications can be built.

Constructor to create a Architecture

Architecture of a program

Data of a program - how information should be encoded.

Constructor to create a DataInfo

Maps for Concepts and Space

Constructor to create a Maps

Default mapping between Space and CodeType.

Constructor to create a Constraints

Constructor to create an ODE

Constructor to create a DocConfig

Constructor to create a LogConfig

Log Configuration

Constructor to create a OptionalFeatures

Code Specification. Holds system information and options.

Creates a CodeSpec using the provided System, Choices, and Mods.

Get a UID of a chunk corresponding to a Func.

Convert a Func to an implementation-stage DefinedQuantityDict representing the function.

Holds module information.

Holds a function definition or function data.

Define an assignment statement.

State variables hold attach a VisibilityTag to a CodeVarChunk.

Define a public state variable based on the given CodeVarChunk.

Define a private state variable based on the given CodeVarChunk.

Define a declare-define statement.

Define a for-loop. Quantity is for the iteration variable, CodeExpr is the upper bound at that variable (the variable will start with a value of 0). [FuncStmt] is for the loop body.

Define a for-loop. Quantity is for the iteration variable, and 3 CodeExprs for the start, stop, step numbers. [FuncStmt] is for the loop body.

Define a function that reads data from a file, according to the given DataDesc.

Define a function by providing the FuncStmts for its body. Other parameters are function name, description, list of parameters, space of the returned value, and description of the returned value.

Define a Mod with the given Name, Description, Classes, and Functions.

Combine an Object-type CodeChunk with another CodeChunk to create a new CodeChunk which represents a field of the first. ex. ccObjVar obj f = obj.f.

Any quantity can be a named argument (wrapper for DefinedQuantityDict), but with more of a focus on generating code arguments.

Smart constructor for NamedArgument .

Structure to hold ODE information.

Basic ODEInfo constructor.

Create ODEInfo with Other variables, ODEOptions, DifferentialModel, and InitialValueProblem

Other parameters for solving the ODE numerically

Basic ODEOptions constructor

Methods for solving ODEs. Includes Runge-Kutta 4-5, Backwards Differentiation Formula, or Adams' method.

Holds an ODE library package.

Makes an ODELibPckg with the given name, ExternalLibrary specification, a list of necessary dummy quantities usage relies on, ExternalLibraryCall specification parameterized by an ODEInfo, local file path to the library, and list of compatible languages.

Makes an ODELibPckg with the given name, ExternalLibrary specification, a list of necessary dummy quantities usage relies on, ExternalLibraryCall specification parameterized by an ODEInfo, and list of compatible languages.