Object-oriented C#/.NET 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 for more information.

Create and execute a module

First, you have to create a LSPModeler environment. As with LocalSolver, we recommend using a “using” statement that will ensure the native memory allocated for the modeler is correctly released when the environment is discarded. LSPModeler is the main class of the Modeler library and allows you to create a module in one of two ways:

Both of these methods return an instance of LSPModule which will enable you to interact with the module variables and functions. To be runnable, a module must implement a model function that will build a LSModel. You can then call LSPModule.Run to start the execution of the module. After the LocalSolver model has been built, the resolution process will be started. You can also import arguments in a module with the method LSPModule.ParseArguments. This method imports each passed argument as a global variable in the module:

using (LSPModeler modeler = new LSPModeler()) {
    LSPModule module = modeler.LoadModule("my_lsp_file.lsp");
    module.ParseArguments("lsIterationLimit=100", "lsTimeLimit=10");

Interacting with variables

You can interact with the variables inside a module thanks to getters and setters on the LSPModule class. Values can be obtained in their native C# type or retrieved as LSPValue which is a container that can hold any type of value inside a module. For more information on value types available in the modeler you can look at LSPType.

You can create maps from the modeler instance with LSPModeler.CreateMap. A map is a data structure holding (key, value) pairs that can also be used as an array. For more information on maps you can look at the map module.

Using external functions

You can use your own C# functions as LSP functions in the modeler thanks to the method LSPModeler.CreateFunction. The signature of the external function must conform to the delegate LSPFunctor:

LSPValue MyLspFunction(LSPModeler modeler, IList<LSPValue> arguments) {
    double result = arguments[0].AsDouble() + arguments[1].AsDouble();
    return modeler.CreateDouble(result);

void Main() {
    LSPFunction lspFunc = modeler.CreateFunction(MyLspFunction);
    List<LSPValue> arguments = new List<LSPValue>();
    LSPValue result = lspFunc.Call(arguments);
    Console.WriteLine("result = " + result.AsDouble()); // prints "result = 3.8"

In the snippet above we declare an LSP function that takes two LSP doubles as input, add them together and returns the result. We can then call the function with LSPFunction.Call to execute the function and retrieve the result.

You can also assign the function to a variable in a module with LSPModule.SetFunction. After doing so, the function will be callable within any function of the module.