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.QN2JAVA;
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, generate source code, and save the interchange document
LayeredNetwork asLayered = QN2LQN.convert(model);
String javaSource = QN2JAVA.generate(model, "rebuildModel");
LineModelIO.save(model, "model.json");

# Python: model transformations
from line_solver import LayeredNetwork, MVA, save_model
from line_solver.io import JSIM2LINE, QN2JSIMG, LQN2QN, pnml_save
from line_solver.api.io.code_gen import qn2matlab, qn2python

# Import a JMT model
model = 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')
pnml_save(model, 'model.pnml')

# Generate scripts, draw the diagram, and save the interchange document
print(qn2python(model, 'my_model'))
print(qn2matlab(model, 'my_model'))
model.exportTikZ('network.pdf')
save_model(model, 'model.json')

// C++: model transformations
#include "line/io/code_gen.h"
#include "line/io/jmt_import.h"
#include "line/io/linemodel.h"
#include "line/io/lqn2qn.h"
#include "line/io/lqnx_io.h"
#include "line/io/pnml.h"
#include "line/io/qn2jsimg.h"
#include "line/io/qn2lqn.h"
#include "line/io/tikz.h"
#include <fstream>

using namespace line;

// Import a JMT model, a layered model, or any interchange document the other three write
qn::Network<double> model = io::jsim2line<double>("mymodel.jsimg");
lqn::LqnModel<double> lqn = io::read_lqnx_model<double>("system.lqnx");
io::LineModel<double> any = io::linemodel_load<double>("model.json");

// Export to JMT and PNML, and convert between formalisms
io::qn2jsimg(model, "exported_model.jsimg");
io::pnml_save(model.get_struct(), "model.pnml");
lqn::LqnModel<double> layered = io::qn2lqn(model);
qn::Network<double> flat = io::lqn2qn(lqn);

// Generate a MATLAB script, draw the diagram, write the interchange back out
std::ofstream script("rebuild_model.m");
io::qn2matlab(model, "my_model", script);
io::export_tikz(model, "network.pdf");
io::linemodel_save(model, "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);