LINE Solver

# Python: name the engine that produces the numbers
from line_solver import Network, MVA

model = Network('MyModel')
# ... define model ...

solver = MVA(model, lang='python')  # native Python (default), no JVM
solver = MVA(model, lang='java')    # the canonical JAR, as a subprocess
solver = MVA(model, lang='cpp')     # the C++ line-cli binary

table = solver.getAvgTable()

// Java: write and read the interchange document
import jline.io.LineModelIO;
import jline.lang.Network;

LineModelIO.save(model, "model.json");
Network reloaded = (Network) LineModelIO.load("model.json");

# Python: write and read the interchange document
from line_solver import save_model, load_model

save_model(model, 'model.json')
model = load_model('model.json')

// C++: write and read the interchange document
#include "line/io/network_reader.h"
#include "line/io/network_writer.h"

using namespace line;

qn::Network<double> model = io::read_network_json<double>("model.json");
io::write_network_json(model.get_struct(), "roundtrip.json");

// Java: model transformations
import jline.io.LineModelIO;
import jline.io.M2M;
import jline.io.PnmlIO;
import jline.io.QN2JSIMG;
import jline.io.QN2LQN;
import jline.lang.Network;
import jline.lang.layered.LayeredNetwork;

// Import a JMT model
Network model = new M2M().JSIM2LINE("mymodel.jsimg");

// Import a layered model
LayeredNetwork lqn = LayeredNetwork.parseXML("system.lqnx");

// Export to JMT, to LQN XML and to PNML
QN2JSIMG.writeJSIM(model, "exported_model.jsimg");
lqn.writeXML("webservice.lqnx");
PnmlIO.save(model, "model.pnml");

// Convert between formalisms, and save the interchange document
LayeredNetwork asLayered = QN2LQN.convert(model);
LineModelIO.save(model, "model.json");

# Python: model transformations
from line_solver import LayeredNetwork, MVA, save_model
from line_solver.io import M2M, QN2JSIMG, LQN2QN
from line_solver.io.pnml_io import save_pnml
from line_solver.api.io.code_gen import qn2python

# Import a JMT model
model = M2M().JSIM2LINE('mymodel.jsimg')
table = MVA(model).getAvgTable()

# Import a layered model, and flatten it to a queueing network
lqn = LayeredNetwork.parse_xml('system.lqnx')
qn = LQN2QN(lqn)

# Export to JMT, to LQN XML and to PNML
QN2JSIMG(model, 'exported_model.jsimg')
lqn.write_xml('webservice.lqnx')
save_pnml(model, 'model.pnml')

# Generate a script, and save the interchange document
print(qn2python(model, 'my_model'))
save_model(model, 'model.json')

// C++: model transformations
#include "line/io/jsim_reader.h"
#include "line/io/network_reader.h"
#include "line/io/network_writer.h"
#include "line/io/pnml.h"
#include "line/io/qn2lqn.h"

using namespace line;

// Import a JMT model, or the interchange document the other three write
qn::Network<double> model = io::read_jsim<double>("mymodel.jsimg");
qn::Network<double> same  = io::read_network_json<double>("model.json");

// Export to PNML, convert to a layered model, write the interchange back out
io::pnml_save(model.get_struct(), "model.pnml");
lqn::LqnModel<double> layered = io::qn2lqn(model);
io::write_network_json(model.get_struct(), "roundtrip.json");

# Build and run the bundled image
cd io/rest-api
docker build -t line-rest .
docker run -p 8080:8080 line-rest

# Same, with authentication enabled
docker run -p 8080:8080 -e LINE_API_KEYS="key1,key2" line-rest

import base64
import requests

# Read model file
with open('mymodel.jsimg', 'rb') as f:
    content = base64.b64encode(f.read()).decode('ascii')

# Solve using REST API
response = requests.post(
    'http://localhost:8080/api/v1/models/solve',
    json={
        'model': {'format': 'jsimg', 'content': content, 'base64': True},
        'solver': 'mva',
        'analysis': 'all',
    },
)

# Parse results
results = response.json()
print(results['status'], results['runtime'])
print(results['results']['avgTable'])

// Solve a model using fetch API
async function solveModel(modelContent) {
    const response = await fetch(
        'http://localhost:8080/api/v1/models/solve',
        {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                model: { format: 'jsimg', content: modelContent, base64: false },
                solver: 'mva',
                analysis: 'all'
            })
        }
    );

    const results = await response.json();
    console.log(results);
    return results;
}

// Health check
fetch('http://localhost:8080/api/v1/health')
    .then(r => r.json())
    .then(console.log);