@frontlinesystems/rason-mcp-server 2026.5.0 → 2026.5.1

package/examples/rason-features/UserGuide/UGProductMixTab3.json

@@ -1,67 +1,67 @@
-{
-    "modelName": "UGProductMixTable3",
-    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1, except that this example passes a SPARSE table (as in UGProductMixTable2) and uses the sortIndexCols property within the parts table.",
-    "modelType": "optimization",
-    "indexSets": {
-        "part": {
-            "value": ["chas", "tube", "cone", "psup", "elec"]
-        },
-        "prod": {
-            "value": ["tv", "stereo", "speaker"]
-        }
-    },
-    "data": {
-        "parts": {
-            "comment": "If the sortIndexCols (or sort) property is used, all indexCols will be sorted alphabetically.  (Note:  The properties sort and sortIndexCols perform the same function.)  Otherwise, the table will be sorted as entered.  In this example, the order for the prod indexCol will be:  speaker, stereo, tv.  While the order for the  part indexCol will be: chas, cone, elec, psup, tube.",
-            "indexCols": ["part", "prod"],
-            "sortIndexCols": true,
-            "value": [
-                ["chas", "tv", 1],
-                ["tube", "tv", 1],
-                ["cone", "tv", 2],
-                ["psup", "tv", 1],
-                ["elec", "tv", 2],
-                ["chas", "stereo", 1],
-                ["cone", "stereo", 2],
-                ["psup", "stereo", 1],
-                ["elec", "stereo", 1],
-                ["cone", "speaker", 1],
-                ["elec", "speaker", 1]
-            ]
-        },
-        "profits": {
-            "comment": "Profit per unit for TVs, Steroes and Speakers.",
-            "dimensions": ["prod"],
-            "value": [75, 50, 35]
-        },
-        "inventory": {
-            "dimensions": ["part"],
-            "value": [450, 250, 800, 450, 600]
-        }
-    },
-    "variables": {
-        "comment":"The x array is dimensioned using the prod index.",
-        "x": {
-            "dimensions": ["prod"],
-            "value": 0,
-            "lower": 0,
-            "finalValue": []
-        }
-    },
-    "constraints": {
-        "for(p in 'part')": {
-            "comment": "parts[p, ] retrieves coefficients for all products containing the part, cone. parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays.",
-            "cons[p]": {
-                "formula": "sumproduct(parts[p, ], x)",
-                "upper": "inventory"
-            }
-        }
-    },
-    "objective": {
-        "total": {
-            "formula": "sumproduct(x, profits)",
-            "type": "maximize",
-            "finalValue": []
-        }
-    }
+{
+    "modelName": "UGProductMixTable3",
+    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1, except that this example passes a SPARSE table (as in UGProductMixTable2) and uses the sortIndexCols property within the parts table.",
+    "modelType": "optimization",
+    "indexSets": {
+        "part": {
+            "value": ["chas", "tube", "cone", "psup", "elec"]
+        },
+        "prod": {
+            "value": ["tv", "stereo", "speaker"]
+        }
+    },
+    "data": {
+        "parts": {
+            "comment": "If the sortIndexCols (or sort) property is used, all indexCols will be sorted alphabetically.  (Note:  The properties sort and sortIndexCols perform the same function.)  Otherwise, the table will be sorted as entered.  In this example, the order for the prod indexCol will be:  speaker, stereo, tv.  While the order for the  part indexCol will be: chas, cone, elec, psup, tube.",
+            "indexCols": ["part", "prod"],
+            "sortIndexCols": true,
+            "value": [
+                ["chas", "tv", 1],
+                ["tube", "tv", 1],
+                ["cone", "tv", 2],
+                ["psup", "tv", 1],
+                ["elec", "tv", 2],
+                ["chas", "stereo", 1],
+                ["cone", "stereo", 2],
+                ["psup", "stereo", 1],
+                ["elec", "stereo", 1],
+                ["cone", "speaker", 1],
+                ["elec", "speaker", 1]
+            ]
+        },
+        "profits": {
+            "comment": "Profit per unit for TVs, Steroes and Speakers.",
+            "dimensions": ["prod"],
+            "value": [75, 50, 35]
+        },
+        "inventory": {
+            "dimensions": ["part"],
+            "value": [450, 250, 800, 450, 600]
+        }
+    },
+    "variables": {
+        "comment":"The x array is dimensioned using the prod index.",
+        "x": {
+            "dimensions": ["prod"],
+            "value": 0,
+            "lower": 0,
+            "finalValue": []
+        }
+    },
+    "constraints": {
+        "for(p in 'part')": {
+            "comment": "parts[p, ] retrieves coefficients for all products containing the part, cone. parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays.",
+            "cons[p]": {
+                "formula": "sumproduct(parts[p, ], x)",
+                "upper": "inventory"
+            }
+        }
+    },
+    "objective": {
+        "total": {
+            "formula": "sumproduct(x, profits)",
+            "type": "maximize",
+            "finalValue": []
+        }
+    }
 }

package/examples/rason-features/UserGuide/UGProductMixTab4.json

@@ -1,71 +1,71 @@
-{
-    "modelName": "UGProductMixTable4",
-    "modelDescription": "RASON Product Mix Example: Solves the same model as UGProductMixTable3. However, in this example, the inventory values are also entered as a table. Also, the constraints are entered in standard form, i.e. sumproduct(x,parts)-inventory <= 0",
-    "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": "In this example, the inventory values are given in a table.",
-            "indexCols": ["part"],
-            "value": [
-                ["chas", 450],
-                ["tube", 250],
-                ["cone", 800],
-                ["psup", 450],
-                ["elec", 600]
-            ]
-        }
-    },
-    "variables": {
-        "x": {
-            "comment": "The x array is dimensioned using the prod index.",
-            "dimensions": ["prod"],
-            "value": 0,
-            "lower": 0,
-            "finalValue": []
-        }
-    },
-    "constraints": {
-        "comment": "Constraints are entered in standard form, i.e. sumproduct(parts, x) - inventory <= 0.  parts[p, ] retrieves coefficients for all products containing the part, cone. parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays.",
-        "for(p in 'part')": {
-            "cons[p]": {
-                "formula": "sumproduct(parts[p, ], x) - inventory[p]",
-                "upper": 0
-            }
-        }
-    },
-    "objective": {
-        "total": {
-            "formula": "sumproduct(x, profits)",
-            "type": "maximize",
-            "finalValue": []
-        }
-    }
+{
+    "modelName": "UGProductMixTable4",
+    "modelDescription": "RASON Product Mix Example: Solves the same model as UGProductMixTable3. However, in this example, the inventory values are also entered as a table. Also, the constraints are entered in standard form, i.e. sumproduct(x,parts)-inventory <= 0",
+    "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": "In this example, the inventory values are given in a table.",
+            "indexCols": ["part"],
+            "value": [
+                ["chas", 450],
+                ["tube", 250],
+                ["cone", 800],
+                ["psup", 450],
+                ["elec", 600]
+            ]
+        }
+    },
+    "variables": {
+        "x": {
+            "comment": "The x array is dimensioned using the prod index.",
+            "dimensions": ["prod"],
+            "value": 0,
+            "lower": 0,
+            "finalValue": []
+        }
+    },
+    "constraints": {
+        "comment": "Constraints are entered in standard form, i.e. sumproduct(parts, x) - inventory <= 0.  parts[p, ] retrieves coefficients for all products containing the part, cone. parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays.",
+        "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/UserGuide/UGProductMixTab5.json

@@ -1,68 +1,68 @@
-{
-    "modelName": "UGProductMixTable5",
-    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1 through 4. In this example, 1. the inventory values are supplied as upper bounds to each of the parts constraints, 2. The final values of the profits table will be included in the result, 3.Each constraint is entered separately.",
-    "modelType": "optimization",
-    "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": {
-            "comment": "In this example, the profits table will be returned in the results, due to the presence of the finalValue property.",
-            "dimensions": ["prod"],
-            "value": [75, 50, 35],
-            "binding": "get",
-            "finalValue": []
-        }
-    },
-    "variables": {
-        "x": {
-            "dimensions": ["prod"],
-            "value": 0,
-            "lower": 0,
-            "finalValue": []
-        }
-    },
-    "constraints": {
-        "comment": "Each constraint is entered separately.  Recall that parts['cone', ] retrieves coefficients for all products containing the part, cone, and parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays. The inventory data is supplied as an upper bound to each constraint.",
-        "c1": {
-            "formula": "sumproduct(parts['chas',], x)",
-            "upper": 450
-        },
-        "c2": {
-            "formula": "sumproduct(parts['tube',], x)",
-            "upper": 250
-        },
-        "c3": {
-            "formula": "sumproduct(parts['cone',], x)",
-            "upper": 800
-        },
-        "c4": {
-            "formula": "sumproduct(parts['psup',], x)",
-            "upper": 450
-        },
-        "c5": {
-            "formula": "sumproduct(parts['elec',], x)",
-            "upper": 600
-        }
-    },
-    "objective": {
-        "total": {
-            "formula": "sumproduct(x, profits)",
-            "type": "maximize",
-            "finalValue": []
-        }
-    }
+{
+    "modelName": "UGProductMixTable5",
+    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1 through 4. In this example, 1. the inventory values are supplied as upper bounds to each of the parts constraints, 2. The final values of the profits table will be included in the result, 3.Each constraint is entered separately.",
+    "modelType": "optimization",
+    "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": {
+            "comment": "In this example, the profits table will be returned in the results, due to the presence of the finalValue property.",
+            "dimensions": ["prod"],
+            "value": [75, 50, 35],
+            "binding": "get",
+            "finalValue": []
+        }
+    },
+    "variables": {
+        "x": {
+            "dimensions": ["prod"],
+            "value": 0,
+            "lower": 0,
+            "finalValue": []
+        }
+    },
+    "constraints": {
+        "comment": "Each constraint is entered separately.  Recall that parts['cone', ] retrieves coefficients for all products containing the part, cone, and parts[,'tv'] would retrieve coefficients for all parts used to build a TV. Both results are vertical arrays. The inventory data is supplied as an upper bound to each constraint.",
+        "c1": {
+            "formula": "sumproduct(parts['chas',], x)",
+            "upper": 450
+        },
+        "c2": {
+            "formula": "sumproduct(parts['tube',], x)",
+            "upper": 250
+        },
+        "c3": {
+            "formula": "sumproduct(parts['cone',], x)",
+            "upper": 800
+        },
+        "c4": {
+            "formula": "sumproduct(parts['psup',], x)",
+            "upper": 450
+        },
+        "c5": {
+            "formula": "sumproduct(parts['elec',], x)",
+            "upper": 600
+        }
+    },
+    "objective": {
+        "total": {
+            "formula": "sumproduct(x, profits)",
+            "type": "maximize",
+            "finalValue": []
+        }
+    }
 }

package/examples/rason-features/UserGuide/UGProjectSelect0.json

@@ -1,92 +1,92 @@
-{
-  "modelName": "UGProjectSelect0Example",
-  "modelDescription": "RASON Example - Simulation Optimization: This example is discussed in the chapter, Defining Your Stochastic Optimization Model, within the RASON User Guide, downloadable from the Help tab. This example is a capital budgeting problem, where the projects being considered for funding have uncertain future cash flows. In this example, simulation optimization is used to find a solution using the Evolutionary Engine. Assume eight different capital projects are proposed for funding in your company. Each one has a known initial investment. Each project has a 90% chance of success, and if a project succeeds, it will have an uncertain (but positive) future cash flow. Funding all eight projects would require a total initial investment of $2.5 million, but our capital budget is only $1.5 million. Hence, we must choose a subset of the projects to fund that will maximize our expected total future cash flow, while ensuring that our total initial investment does not exceed our $1.5 million budget.",
-  "comment": "Note that modelType is set to 'optimization', rather than 'simulation'. If modelType=simulation and POST rason.net/api/model/{nameorid}/solve is called to solve a stochastic optimization model, the workflow engine will run a simulation, only. In order to solve the model using stochastic optimization, you must specify 'modelType' =  'optimization'.",
-  "modelType": "optimization",
-  "modelSettings": {
-    "comment": "When the model option simulationOptimization is set to True, the Evolutionary engine will be used to solve the model. The idea behind simulation optimization is straightforward: For each set of values for the decision variables considered by the optimizer, we perform one simulation, a compute user-specified summary measure – such as PsiMean(cash) in the Project Selection model – for the constraints and/or objective that depend on uncertainty. The optimizer uses these summary measures to decide what set of values it should try next for the decision variables – and the process is repeated. The great strength of simulation optimization is its generality – but this is also its weakness: It requires a new simulation at each step of the optimization, and because the method assumes no structure in the model, in general the number of steps can grow exponentially with the number of variables and constraints. ",
-    "simulationOptimization": true,
-    "numTrials": 1000
-  },
-  "engineSettings": {
-    "comment": "The random seed setting is set to 1 in order to create reproducible results.",
-    "randomSeed": 1
-  },
-  "variables": {
-    "x": {
-      "comment": "The x decision variable array will hold our 0-1 (binary) decision variables. If a variable is set to 1, the project is selected. If a variable is set to 0, the project is not selected.",
-      "dimensions": [ 8 ],
-      "type": "binary",
-      "finalValue": []
-    }
-  },
-  "uncertainVariables": {
-    "comment": "To model the uncertainty in this problem, PSI functions are used that define uncertain variables with probability distributions within the uncertainVariables section. ",
-    "successCashFlow": {
-      "comment": "The uncertain variable, successCashFlow models the cash flow of a successful project. It is created here with 8 elements. Then the array is populated using the PsiTriangular() function, specifying a minimum, most likely and maximum cash flow for each of the 8 projects.",
-      "dimensions": [ 8 ]
-    },
-    "successCashFlow[1]": {
-      "comment": "Models cash flow for project 1.",
-      "formula": "PsiTriangular(400000, 500000, 900000)"
-    },
-    "successCashFlow[2]": {
-      "comment": "Models cash flow for project 2.",
-      "formula": "PsiTriangular(500000, 750000, 1250000)"
-    },
-    "successCashFlow[3]": {
-      "comment": "Models cash flow for project 3.",
-      "formula": "PsiTriangular(500000, 1000000,1500000)"
-    },
-    "successCashFlow[4]": {
-      "comment": "Models cash flow for project 4.",
-      "formula": "PsiTriangular(400000, 600000, 900000)"
-    },
-    "successCashFlow[5]": {
-      "comment": "Models cash flow for project 5.",
-      "formula": "PsiTriangular(250000, 500000, 750000)"
-    },
-    "successCashFlow[6]": {
-      "comment": "Models cash flow for project 6.",
-      "formula": "PsiTriangular(300000, 500000, 600000)"
-    },
-    "successCashFlow[7]": {
-      "comment": "Models cash flow for project 7.",
-      "formula": "PsiTriangular(200000, 450000, 700000)"
-    },
-    "successCashFlow[8]": {
-      "comment": "Models cash flow for project 8.",
-      "formula": "PsiTriangular(400000, 500000, 700000)"
-    },
-    "successProbability": {
-      "comment": "To model the chance of success we create the variable successProbability (within formulas) using the probability distribution, =PsiBinomial(1,0.9). On each trial, this distribution returns 1 with probability 90% and 0 with probability 10%.",
-      "dimensions": [ 8 ],
-      "formula": "PsiBinomial(1, 0.9)"
-    }
-  },
-  "formulas": {
-    "comment": "In formulas, cash multiplies the net cash flow from each project, expected cash flow minus the initial investment, by the x array which holds our binary decision variables.",
-    "initialInvest": {
-      "value": [ 325000, 450000, 550000, 300000, 150000, 250000, 150000, 325000 ]
-    },
-    "cash": {
-      "formula": "sumproduct(successCashFlow * successProbability - initialInvest, x)"
-    }
-  },
-  "constraints": {
-    "comment": "Inside constraints, invest calculates the constraint that ensures that the total initial investment does not exceed $1,500,000, (initialInvest multiplied by the 0-1 decision variables in the x array).",
-    "invest": {
-      "formula": "sumproduct(initialInvest, x)",
-      "upper": 1500000
-    }
-  },
-  "objective": {
-    "comment": "The objective maximizes the expected mean of cash by setting the chanceType property to ExpVal. ",
-    "total": {
-      "type": "maximize",
-      "formula": "cash",
-      "chanceType": "ExpVal",
-      "finalValue": []
-    }
-  }
+{
+  "modelName": "UGProjectSelect0Example",
+  "modelDescription": "RASON Example - Simulation Optimization: This example is discussed in the chapter, Defining Your Stochastic Optimization Model, within the RASON User Guide, downloadable from the Help tab. This example is a capital budgeting problem, where the projects being considered for funding have uncertain future cash flows. In this example, simulation optimization is used to find a solution using the Evolutionary Engine. Assume eight different capital projects are proposed for funding in your company. Each one has a known initial investment. Each project has a 90% chance of success, and if a project succeeds, it will have an uncertain (but positive) future cash flow. Funding all eight projects would require a total initial investment of $2.5 million, but our capital budget is only $1.5 million. Hence, we must choose a subset of the projects to fund that will maximize our expected total future cash flow, while ensuring that our total initial investment does not exceed our $1.5 million budget.",
+  "comment": "Note that modelType is set to 'optimization', rather than 'simulation'. If modelType=simulation and POST rason.net/api/model/{nameorid}/solve is called to solve a stochastic optimization model, the workflow engine will run a simulation, only. In order to solve the model using stochastic optimization, you must specify 'modelType' =  'optimization'.",
+  "modelType": "optimization",
+  "modelSettings": {
+    "comment": "When the model option simulationOptimization is set to True, the Evolutionary engine will be used to solve the model. The idea behind simulation optimization is straightforward: For each set of values for the decision variables considered by the optimizer, we perform one simulation, a compute user-specified summary measure – such as PsiMean(cash) in the Project Selection model – for the constraints and/or objective that depend on uncertainty. The optimizer uses these summary measures to decide what set of values it should try next for the decision variables – and the process is repeated. The great strength of simulation optimization is its generality – but this is also its weakness: It requires a new simulation at each step of the optimization, and because the method assumes no structure in the model, in general the number of steps can grow exponentially with the number of variables and constraints. ",
+    "simulationOptimization": true,
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "comment": "The random seed setting is set to 1 in order to create reproducible results.",
+    "randomSeed": 1
+  },
+  "variables": {
+    "x": {
+      "comment": "The x decision variable array will hold our 0-1 (binary) decision variables. If a variable is set to 1, the project is selected. If a variable is set to 0, the project is not selected.",
+      "dimensions": [ 8 ],
+      "type": "binary",
+      "finalValue": []
+    }
+  },
+  "uncertainVariables": {
+    "comment": "To model the uncertainty in this problem, PSI functions are used that define uncertain variables with probability distributions within the uncertainVariables section. ",
+    "successCashFlow": {
+      "comment": "The uncertain variable, successCashFlow models the cash flow of a successful project. It is created here with 8 elements. Then the array is populated using the PsiTriangular() function, specifying a minimum, most likely and maximum cash flow for each of the 8 projects.",
+      "dimensions": [ 8 ]
+    },
+    "successCashFlow[1]": {
+      "comment": "Models cash flow for project 1.",
+      "formula": "PsiTriangular(400000, 500000, 900000)"
+    },
+    "successCashFlow[2]": {
+      "comment": "Models cash flow for project 2.",
+      "formula": "PsiTriangular(500000, 750000, 1250000)"
+    },
+    "successCashFlow[3]": {
+      "comment": "Models cash flow for project 3.",
+      "formula": "PsiTriangular(500000, 1000000,1500000)"
+    },
+    "successCashFlow[4]": {
+      "comment": "Models cash flow for project 4.",
+      "formula": "PsiTriangular(400000, 600000, 900000)"
+    },
+    "successCashFlow[5]": {
+      "comment": "Models cash flow for project 5.",
+      "formula": "PsiTriangular(250000, 500000, 750000)"
+    },
+    "successCashFlow[6]": {
+      "comment": "Models cash flow for project 6.",
+      "formula": "PsiTriangular(300000, 500000, 600000)"
+    },
+    "successCashFlow[7]": {
+      "comment": "Models cash flow for project 7.",
+      "formula": "PsiTriangular(200000, 450000, 700000)"
+    },
+    "successCashFlow[8]": {
+      "comment": "Models cash flow for project 8.",
+      "formula": "PsiTriangular(400000, 500000, 700000)"
+    },
+    "successProbability": {
+      "comment": "To model the chance of success we create the variable successProbability (within formulas) using the probability distribution, =PsiBinomial(1,0.9). On each trial, this distribution returns 1 with probability 90% and 0 with probability 10%.",
+      "dimensions": [ 8 ],
+      "formula": "PsiBinomial(1, 0.9)"
+    }
+  },
+  "formulas": {
+    "comment": "In formulas, cash multiplies the net cash flow from each project, expected cash flow minus the initial investment, by the x array which holds our binary decision variables.",
+    "initialInvest": {
+      "value": [ 325000, 450000, 550000, 300000, 150000, 250000, 150000, 325000 ]
+    },
+    "cash": {
+      "formula": "sumproduct(successCashFlow * successProbability - initialInvest, x)"
+    }
+  },
+  "constraints": {
+    "comment": "Inside constraints, invest calculates the constraint that ensures that the total initial investment does not exceed $1,500,000, (initialInvest multiplied by the 0-1 decision variables in the x array).",
+    "invest": {
+      "formula": "sumproduct(initialInvest, x)",
+      "upper": 1500000
+    }
+  },
+  "objective": {
+    "comment": "The objective maximizes the expected mean of cash by setting the chanceType property to ExpVal. ",
+    "total": {
+      "type": "maximize",
+      "formula": "cash",
+      "chanceType": "ExpVal",
+      "finalValue": []
+    }
+  }
 }