Hexaly Modeler
Object-oriented C++ APIs are provided for the virtual machine powering the LSP
language. With only a few classes, you can load modules, interact with their
variables and execute them. If you are not familiar with the LSP language,
please have a look at the language reference
Create a module
First, you have to create a LSPModeler
Both of these methods return an instance of LSPModule
Launch a module
There are two launch modes for a module:
Optimization mode: This is the classic and default mode for the modeler.
At the very least, you must implement a model LSPModule::run() LSPModeler::createSolver()
Note that the run method also accepts as a parameter a list of arguments
that will be passed as global variables to your module:
LSPModeler modeler ;
LocalSolver ls = modeler . createSolver ();
LSPModule module = modeler . loadModule ( "module_name" , "my_lsp_file.lsp" );
module . run ( ls , { "lsIterationLimit=100" , "lsTimeLimit=10" });
Main mode: In this mode, the modeler behaves like a classical programming
language. To use this mode, you have to implement a function named
main input model param display output LSPModule::runMain()
Note that unlike the optimization mode, it is your responsibility to
manually create the solver instances, close your models and launch the
resolutions. In return, you are free to run several successive resolutions
or none at all if you just want to use LSP for its pure programming
features.
For more details on the differences between the optimization and the main
mode, read Main mode
Interacting with variables
You can interact with the variables inside a module thanks to getters and
setters on the LSPModule LSPValue LSPType
You can create maps from the modeler instance with
LSPModeler::createMap() map module
Using external functions
You can use your own C++ functions as
LSP functions LSPModeler::createFunction() LSPFunctor call()
class MyLspFunction : public LSPFunctor {
LSPValue call ( LSPModeler & modeler , const std :: vector < LSPValue >& arguments ) {
lsdouble result = arguments [ 0 ]. asDouble () + arguments [ 1 ]. asDouble ();
return modeler . createDouble ( result );
}
}
MyLspFunction myFunc ;
LSPFunction lspFunc = modeler . createFunction ( & myFunc );
LSPValue args [ 2 ] = { modeler . createDouble ( 1.5 ), modeler . createDouble ( 2.3 )};
LSPvalue result = lspFunc . call ( args , 2 );
std :: cout << "result = " << result . asDouble () << std :: endl ; // prints "result = 3.8"
In the snippet above we declare an LSP function that takes two LSP doubles as
input, adds them together and returns the result. We can then call the
function with LSPFunction::call()
You can also assign the function to a variable in a module with
LSPModule::setFunction()
