@frontlinesystems/rason-mcp-server 2026.5.0

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/DataFiltering/ListwithFilter.json

@@ -0,0 +1,53 @@
+{
+    "modelName": "ListwithFilter",
+    "modelDescription": "Example illustrating how to filter a table (list).",
+    "modelType": "calculation",
+    "typeDefs": {
+        "comment": "This section defines custom data structures used in the model.",
+      "tLoanList": {
+        "comment": "A custom type named tLoanList, defined using FEEL language. This is a collection of items.  The names of the fields (all of type number) are:  principal, rate and termMonths. ", 
+        "language": "FEEL",
+        "isCollection": true,
+        "components": [ "principal", "rate", "termMonths" ],
+        "types": [ "number", "number", "number" ]
+      }
+    },
+  "data": {
+    "comment":  "Data provided in this section. The 'binding: get'' field indicates this data can be accessed from outside the model environment.",
+    "arr": {
+      "value": [ 0, 1, 2, 3, 4, 5 ],
+      "binding": "get"
+    },
+    "list": {
+      "type": "tLoanList",
+      "value": [
+        [ 600000, 0.0275, 360 ],
+        [ 300000, 0.03, 360 ]
+      ],
+      "binding": "get"
+    }
+  },
+  "formulas": {
+    "comment": "Defines computed fields using expressions or FEEL formulas.",
+    "resExc": {
+      "comment": "Filters arr to include only even numbers greater than 0",
+      "formula": "arr[AND(item > 0, ISEVEN(item))]",
+      "finalValue": []
+    },
+    "resFeel": {
+      "comment": "Same logic as above, but using FEEL syntax instead of expression syntax.",
+      "feelFormula": "arr[item > 0 and even(item)]",
+      "finalValue": []
+    },
+    "selExc": {
+      "comment": "Filters the list of loans to only include those with a rate less than 3%.",
+      "formula": "list[rate < 0.03]",
+      "finalValue": []
+    },
+    "selFeel": {
+      "comment": "Same logic as above, but using FEEL syntax instead of expression syntax.",
+      "feelFormula": "list[rate < 0.03]",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/Loops/ProductMix5.json

@@ -0,0 +1,58 @@
+{
+  "modelName": "ProductMix5",
+  "modelDescription": "Solves the product mix example using constraints defined with a for statement and indexed arrays.",
+  "modelType": "optimization",
+  "variables": {
+    "x": {
+      "comment": "Decision variables: quantity produced of each product (one variable per product). Lower bound of 0 for each variable. Final values are requested in the solution.",
+      "lower": [ 0, 0, 0 ],
+      "finalValue": []
+    }
+  },
+  "data": {
+    "profits": {
+      "comment": "Profit per unit for each product. $75 for TVS, $50 for stereos and $35 for speakers. The binding:get property allows these values to be changed outside of the model environment. Values will be available in the solution.",
+      "dimensions": [ 3 ],
+      "value": [ 75, 50, 35 ],
+      "binding": "get",
+      "finalValue": []
+
+    },
+
+    "parts": {
+      "comment": "Parts usage matrix: parts[p,i] = units of part p required to produce product i",
+      "dimensions": [ 5, 3 ],
+      "value": [
+        [ 1, 1, 0 ],
+        [ 1, 0, 0 ],
+        [ 2, 2, 1 ],
+        [ 1, 1, 0 ],
+        [ 2, 1, 1 ]
+      ]
+    },
+
+    "inventory": {
+      "comment": "Available inventory for each part (one value per part)",
+      "value": [ 450, 250, 800, 450, 600 ]
+    }
+  },
+
+  "constraints": {
+    "comment": "Create one inventory constraint for each part",
+    "for(p in 1..5)": {
+      "comment": "Total usage of part p across all products cannot exceed available inventory",
+      "cons[p]": {
+        "formula": "sumproduct(parts[p,], transpose(x))",
+        "upper": "inventory"
+      }
+    }
+  },
+  "objective": {
+    "comment": "Maximize total profit across all products",
+    "total": {
+      "formula": "sumproduct(x, profits)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/Loops/compoundWhileStatement.json

@@ -0,0 +1,36 @@
+{
+  "modelName": "compoundWhileStatement",
+  "modelDescription": "example of compound and while statements",
+  "modelType": "calculation",
+  "data": {
+    "f": {
+      "dimensions": [ 5 ],
+      "value": 0
+    },
+    "i": {
+      "value": 1
+    }
+  },
+  "formulas": {
+    "compound": {
+      "i": {
+        "value": 1,
+        "comment": "need to reset it in case of multiple calculation"
+      },
+      "while(i <= 5)": {
+        "sum(j in 1..i)": {
+          "s": {
+            "formula": "j"
+          }
+        },
+        "f[i]": {
+          "formula": "s",
+          "finalValue": []
+        },
+        "i": {
+          "formula": "i + 1"
+        }
+      }
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/Loops/ifThenElseStatement.json

@@ -0,0 +1,34 @@
+{
+  "modelName": "ifThenElseStatement",
+  "modelDescription": "example of if-then-else statement",
+  "modelType": "calculation",
+  "data": {
+    "comment": "Creates array with 5 entries (indexed 1..5). Initial value for all elements = 0.",
+    "f": {
+      "dimensions": [ 5 ],
+      "value": 0
+    }
+  },
+
+  "formulas": {
+    "comment": "Loops over i = 1, 2, 3, 4, 5",
+    "loop(i in 1..5)": {
+      "comment": "If i is greater than 1, compute f[i] based on previous entry",
+      "if(i > 1)": {
+        "comment": "Take the previous element f[i-1] and add i",
+        "f[i]": {
+          "formula": "f[i-1] + i",
+          "finalValue": []
+        }
+      },
+
+      "else": {
+        "comment": "Otherwise (i == 1), initialize the first element",
+        "f[i]": {
+          "comment": "Set f[1] = 1",
+          "value": 1
+        }
+      }
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/Loops/nestedLoop.json

@@ -0,0 +1,26 @@
+{
+  "modelName": "nestedLoops",
+  "modelDescription": "Example of a nested loop",
+  "modelType": "calculation",
+  "data": {
+    "comment": "Creates array with 5 entries (indexed 1..5). Initial value for all elements = 0.",
+    "f": {
+      "dimensions": [ 5 ],
+      "value": 0
+    }
+  },
+  "formulas": {
+    "comment": "Creates loop that generates a running total and assigns total to variable, f[i].",
+    "loop(i in 1..5)": {
+      "sum(j in 1..i)": {
+        "s": {
+          "formula": "j"
+        }
+      },
+      "f[i]": {
+        "formula": "s",
+        "finalValue": []
+      }
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/ParallelArray.json

@@ -0,0 +1,48 @@
+{
+  "modelName": "AirlineHub2Example",
+  "modelDescription": "This example is identical to Airline Hub 2 RASON Nonlinear Optimization Example. This example showcases how to use an array to formulate multiple constraints at once.",
+  "modelType": "optimization",
+  "variables": {
+    "comment": "There are 3 variables in the model: x, y and z.  x and y are the (x, y) coordinates of the proposed hub location. z is an artificial variable that will be minimized in the objective. The initial value of each variable is set to 1 using the value property and the final values will be returned in the result due to the presence of the keyword, finalValue.",
+
+    "x": {
+      "value": 1.0,
+      "finalValue": []
+    },
+    "y": {
+      "value": 1.0,
+      "finalValue": []
+    },
+    "z": {
+      "value": 1.0,
+      "finalValue": []
+    }
+  },
+  "data": {
+    "comment": "The data section holds the x and y coordinates of each of the 6 airports. Supplying the x and y coordinates in two arrays allows all 6 constraints to be entered as a constraint block.  See 'constraints' section below. In this example, the size of the arrays are inferred by the number of values passed to each array.",
+    "dx": {
+      "comment": "These are the x coordinates of each of the 6 airports.",
+      "value": [ 1, 0.5, 2, 2, 2, 0.5 ]
+    },
+    "dy": {
+      "comment": "These are the y coordinates of each of the 6 airports.",
+      "value": [ 4, 3, 4, 2, 5, 6 ]
+    }
+  },
+  "constraints": {
+    "comment": "In this example, all six constraints are entered at once. This was made possible by the x and y coordinates being supplied via two arrays, dx and dy. Each constraint calculates the distance between the proposed hub and each of the 6 airports. Each constraint is of the form SQRT((x1 - x0) + (y1 - y0)) <= z where z is the artificial variable.  When z is minimized in the objective, it has a 'squashing' effect that pushes the distance formula to be as small as possible, thereby moving the (x,y) coordinates to such a place that minimizes the distance between the hub and all 6 airports. (To convert the constraint to standard form, z is subtracted from both sides of the equation, leaving SQRT((x1 - x0) + (y1 - y0)) - z <= 0.)  Notice that the 'dimensions' propety is used to explicitly create the array of size 6.",
+    "distance": {
+      "dimensions": [ 6 ],
+      "formula": "sqrt((x - dx)^2 + (y - dy)^2) - z",
+      "upper": 0
+    }
+  },
+  "objective": {
+    "obj": {
+      "comment": "Minimize the artificial variable z.  This minimization 'squashes' all six of the distance formulas.  The resulting (x,y) coordinate will be the coordinate that minimizes the distance between the hub and all six airports.",
+      "formula": "z",
+      "type": "minimize",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/indexedArray.json

@@ -0,0 +1,70 @@
+{
+  "modelName": "indexedArray",
+  "modelDescription": "Solves the product mix example problem. However, in this example, the constraints are created using a 'for' statement, an indexed array. For more information on this example, see RASON Examples -- Example Models Discussed in RASON User Guide -- UGProductMixTab4.json.",
+  "modelType": "optimization",
+  "indexSets": {
+    "part": {
+      "value": [ "chas", "tube", "cone", "psup", "elec" ]
+    },
+    "prod": {
+      "value": [ "tv", "stereo", "speaker" ]
+    }
+  },
+  "data": {
+    "parts": {
+      "indexCols": [ "part", "prod" ],
+      "value": [
+        [ "chas", "tv", 1 ],
+        [ "elec", "stereo", 1 ],
+        [ "tube", "tv", 1 ],
+        [ "cone", "tv", 2 ],
+        [ "cone", "stereo", 2 ],
+        [ "chas", "stereo", 1 ],
+        [ "cone", "speaker", 1 ],
+        [ "psup", "tv", 1 ],
+        [ "psup", "stereo", 1 ],
+        [ "elec", "tv", 2 ],
+        [ "elec", "speaker", 1 ]
+      ]
+    },
+    "profits": {
+      "dimensions": [ "prod" ],
+      "value": [ 75, 50, 35 ]
+    },
+    "inventory": {
+      "comment": "inventory values by part",
+      "indexCols": [ "part" ],
+      "value": [
+        [ "chas", 450 ],
+        [ "tube", 250 ],
+        [ "cone", 800 ],
+        [ "psup", 450 ],
+        [ "elec", 600 ]
+      ]
+    }
+  },
+  "variables": {
+    "x": {
+      "dimensions": [ "prod" ],
+      "value": 0,
+      "lower": 0,
+      "finalValue": []
+    }
+  },
+  "constraints": {
+    "comment": "Constraints created using indexed array formula, a declarative construct used to assign attributes across an indexed array.",
+    "for(p in 'part')": {
+      "cons[p]": {
+        "formula": "sumproduct(parts[p, ], x) - inventory[p]",
+        "upper": 0
+      }
+    }
+  },
+  "objective": {
+    "total": {
+      "formula": "sumproduct(x, profits)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/Arrays_Loops_Tables/ArrayExamples/nonParallelArray.json

@@ -0,0 +1,50 @@
+{
+  "modelName": "nonParallelArrayExample",
+  "modelDescription": "This example is identical to the ProductMix4 .json example under RASON Examples-Optimization-LinearExamples. It is included here to showcase the non-parallel array 'num_used' in the 'constraints' section, below.",
+  "modelType": "optimization",
+  "variables": {
+    "x": {
+      "dimensions": [ 3 ],
+      "value": 0,
+      "lower": 0,
+      "finalValue": []
+    }
+  },
+  "data": {
+    "profits": {
+      "dimensions": [ 3 ],
+      "value": [ 75, 50, 35 ],
+      "binding": "get",
+      "finalValue": []
+    },
+    "parts": {
+      "dimensions": [ 5, 3 ],
+      "value": [
+        [ 1, 1, 0 ],
+        [ 1, 0, 0 ],
+        [ 2, 2, 1 ],
+        [ 1, 1, 0 ],
+        [ 2, 1, 1 ]
+      ]
+    },
+    "inventory": {
+      "value": [ 450, 250, 800, 450, 600 ]
+    }
+  },
+  "constraints": {
+    "comment": "5 constraints are created in this section.",
+    "num_used": {
+      "comment": "This type of array formula is evaluated only once as a single operation. The MMULT function is evaluated as one function call that internally performs a matrix–vector multiplication and returns an array of size 5. The resulting multi-dimensional output is then assigned to the array variable num_used, which is defined as a one-dimensional vertical array of length 5. Since this formula appears in the constraints section, the solver automatically generates one constraint for each element of the resulting array.",
+      "dimensions": [ 5 ],
+      "formula": "MMULT(parts, x)",
+      "upper": "inventory"
+    }
+  },
+  "objective": {
+    "total": {
+      "formula": "sumproduct(x, profits)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}