LINE Solver

# Python: Force Java backend execution
from line_solver import Network, MVA

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

# Use Python native implementation (default)
solver = MVA(model, lang='python')

# Use Java backend implementation
solver = MVA(model, lang='java')

# Python: Model transformations
from line_solver import Network, Source, Queue, Sink
from line_solver import SchedStrategy, Exp, OpenClass
from line_solver import JLINE, JSIM2LINE, MVA, QN2JSIMG, M2M, SolverLN

# Build and transform model
model = Network('Example')
source = Source(model, 'Source')
queue = Queue(model, 'Queue', SchedStrategy.FCFS)
sink = Sink(model, 'Sink')
jobclass = OpenClass(model, 'Class1')
source.setArrival(jobclass, Exp(1.0))
queue.setService(jobclass, Exp(2.0))
model.link(Network.serialRouting(source, queue, sink))

# Transform to/from Java backend
java_model = JLINE.line_to_jline(model)
recovered_model = JLINE.jline_to_line(java_model)

# Import JMT model
model = JSIM2LINE('mymodel.jsimg')
solver = MVA(model)
results = solver.avg_table()

# Import LQNS model
m2m = M2M()
lqn_model = m2m.LQN2PYTHON('system.lqnx')
solver = SolverLN(lqn_model)

# Export to JMT format
QN2JSIMG(model, 'exported_model.jsimg')

// Java: Accessing MAP matrices (BUTools format)
import jline.lang.processes.MAP;
import jline.lang.processes.PH;
import jline.util.matrix.Matrix;

MAP map = MAP.rand(3);  // Create random 3-phase MAP

// Extract D0 and D1 matrices (BUTools format)
Matrix D0 = map.D(0);  // Generator matrix for transitions without arrivals
Matrix D1 = map.D(1);  // Rate matrix for transitions with arrivals

// For PH distributions:
PH ph = PH.fit(2.0, 1.5, 2.0);  // Fit from moments
Matrix alpha = ph.getInitProb();      // Initial probability vector
Matrix T = ph.getSubgenerator();      // Subgenerator matrix

# Python: Accessing MAP matrices (BUTools format)
from line_solver import MAP, PH

map_proc = MAP.rand(3)  # Create random 3-phase MAP

# Extract D0 and D1 matrices (BUTools format)
D0 = map_proc.D(0)  # Generator matrix for transitions without arrivals
D1 = map_proc.D(1)  # Rate matrix for transitions with arrivals

# For PH distributions:
ph = PH.fit(2.0, 1.5, 2.0)  # Fit from moments
alpha = ph.getInitProb()    # Initial probability vector
T = ph.getSubgenerator()    # Subgenerator matrix

// Java: MAP representation conversions
import jline.lang.processes.MAP;
import jline.lang.processes.MMDP;
import jline.util.matrix.MatrixCell;

MAP map = MAP.rand(3);

// Get time-reversed MAP (useful for queue analysis)
MAP mapReversed = map.toTimeReversed();

// Convert to MMDP for fluid queue analysis
MMDP mmdp = MMDP.fromMAP(map);

// Get renewal process (removes temporal correlation)
MatrixCell renewalProcess = map.getRenewalProcess();

// Extract moments and statistics
double meanInterarrival = map.getMean();
double scv = map.getSCV();
double skewness = map.getSkewness();

// Start REST server programmatically
import jline.api.REST;

// Start server on port 8080
REST.start(8080);

import requests

# Read model file
with open('mymodel.jsimg', 'r') as f:
    model_content = f.read()

# Solve using REST API
response = requests.post(
    'http://localhost:8080/solve',
    params={'solver': 'mva', 'format': 'jsimg'},
    headers={'Content-Type': 'application/xml'},
    data=model_content
)

# Parse results
results = response.json()
print(results)

// Solve a model using fetch API
async function solveModel(modelContent) {
    const response = await fetch(
        'http://localhost:8080/solve?solver=mva&format=jsimg',
        {
            method: 'POST',
            headers: { 'Content-Type': 'application/xml' },
            body: modelContent
        }
    );

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

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