Solver SDK® Platform

About the RASON® Language and REST API

RASON is a mini-language you can use to quickly and easily create and solve analytic models -- currently optimization and simulation/risk analysis models, soon to include data mining and predictive analytics models. You can use RASON tools on Windows desktops and servers, but the RASON service is especially useful if you are building Web or mobile applications, and you’re familiar with RESTful web services.

RASON stands for Restful Analytic Solver® Object Notation. It offers many benefits compared to using a traditional modeling language, using Excel to create analytic models, or writing analytic models in a programming language. Solver SDK supports RASON models, but you can also create them independently and solve them using Frontline's REST API service -- sign up for a free account at Rason.com.

An Example Model

Below is an example RASON optimization model. Its purpose is to find the optimal location for an airline hub that serves six cities. The cities are located at the (simplified x-y) coordinates given by the dx and dy parameters in the data section. Our goal is to find the x, y coordinates of the airline hub that will minimize the distance flown to any of the cities.

{
    engineSettings : { engine : "GRG Nonlinear" },
    variables :
    {
        x : { value: 1.0, finalValue: [] },
        y : { value: 1.0, finalValue: [] },
        z : { value: 1.0, finalValue: [] }
    },
    data :
    {
        dx : { dimensions: [6], value: [1, 0.5, 2, 2, 2, 0.5] },
        dy : { dimensions: [6], value: [4,   3, 4, 2, 5,   6] }
    },
    constraints :
    {
        c : { dimensions: [6], upper: 0, formula: "sqrt((x - dx)^2 + (y - dy)^2) - z" }
    },
    "objective" :
    {
        "z" : { "type": "minimize", "finalValue": [] }
    }
}

Web developers will recognize the overall syntax as that of JSON, JavaScript Object Notation -– except that identifiers and keywords are not surrounded by double quotes, outside the “objective” section which shows an example of writing “strict JSON”. The RASON Interpreter doesn’t require the quotes in a model, but the result -– the optimal solution to this nonlinear model -– is always valid JSON:

{
    "status" : { "code" : 0 },
    "variables" : {
         "x" : { "finalValue" : 1.250000 },
         "y" : { "finalValue" : 4.000000 },
         "z" : { "finalValue" : 2.136001 }
    },
    "objective" : {
         "z" : { "finalValue" : 2.136001 }
    }
} 

RASON Models vs. Alternatives

How do RASON™ models compare to alternative ways of building analytic applications?

• Compared to a modeling language such as AMPL or GAMS for optimization, or ARENA for simulation, RASON models have similar expressive power, and are easy to understand. But as you’ll see below, it is much easier to use a RASON model in a Web, mobile or server application.
• Compared to Excel as a modeling language, RASON models can use essentially all of Excel’s operators and built-in functions, but it is much easier to build “dimensionally flexible” RASON models, and to use a RASON model in a Web, mobile or server application.
• Compared to writing a model in programming language code, RASON models are “higher level” – much easier to create, modify and understand. But as you’ll see below, RASON models are so easy to manipulate in code that you don’t give up any flexibility.

If you aren’t familiar with modeling languages, you may not realize how much the RASON language is doing for you. Note that the expression "sqrt((x - dx)^2 + (y - dy)^2) - z" is an array expression operating over all six cities. The RASON™ Interpreter computes not just the values of this expression, but its partial derivatives with respect to x and y – used by the nonlinear optimizer to guide the search for a solution.

Server-Based Applications

What if you want to define and solve this model in an application on a corporate server or Web server? That's easy: Since the RASON Interpreter is embedded in Solver SDK Platform, you can simply load and run a RASON model from a text file on the server:

Problem prob = new Problem();
prob.Load("model.json");
prob.Solver.Optimize();
MessageBox.Show(prob.FcnObjective.FinalValue[0].ToString());

This C# example just hints at how you can easily access RASON model elements from code, to update data, optimize or simulate, modify the model, or monitor the solver’s progress.

Web and Mobile Applications

What if you want to define and solve a model in a mobile application written in JavaScript? Solver SDK and plug-in Solver Engines (or other optimizers) won't run directly on a mobile device, nor would they be the best solution. But it’s simple to send a model to the RASON™ REST Server, and get the optimal solution:

    var request = { "variables" : { ...
    "z" : { "type": "minimize", "finalValue": [] } } };
    $.post("https://rason.net/optimize", JSON.stringify(request)
    .done(function(response){
    alert(response.objective.z.finalValue);
    });

Since RASON is JSON, we can write the entire model as an object constant in JavaScript, assigned to the variable request. Then (using JQuery syntax) we make an AJAX request to the RASON Server’s REST API endpoint optimize, which means “optimize this model and immediately return the result.” When the server returns a response, the “done” function is called, and it can easily reference the final value of the objective, since the response is also JSON.

What about a mixed-integer or global optimization model that might take 30 minutes – or overnight - to run? That’s easy: With a POST to rason.net/model, you can create a “model resource,” then start an optimization via GET rason.net/model/id/optimize, check on its progress at any time with GET rason.net/model/id/status, and obtain results when finished with GET rason.net/model/id/result.