@frontlinesystems/rason-mcp-server 2026.5.0

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

@@ -0,0 +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": []
+        }
+    }
+}

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

@@ -0,0 +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": []
+        }
+    }
+}

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

@@ -0,0 +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": []
+        }
+    }
+}

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

@@ -0,0 +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": []
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+{
+  "modelName": "UGProjectSelect1Example",
+  "modelDescription": "RASON Stochastic Optimization Example:  This example is a Stochastic LP and is discussed in the chapter, Defining Your Stochastic Optimization Model, within the RASON User Guide (downloadable from the Help tab). The original model, UGProjectSelect0 (Examples -- Models discussed in User Guide -- UGProjectSelect0.json) is solved via Simulation Optimization.  However, there are two additional methods besides simulation optimization that can solve Stochastic LPs, stochastic programming and robust optimization. For this model, we will choose a transformation to Stochastic Programming Deterministic Equivalent by replacing simulationOptimization: True with transformStochastic: deterministicEquivalent in modelSettings.",
+  "modelType": "optimization",
+  "modelSettings": {
+    "comment": "To use stochastic programming deterministic equivalent, set transformStochastic to deterministicEquivalent. The number of trials is set to 1000, the default. The rest of the model remains unchanged from the original example, UGProjectSelect0. ",
+    "transformStochastic": "deterministicEquivalent",
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "randomSeed": 1
+  },
+  "variables": {
+    "x": {
+      "dimensions": [ 8 ],
+      "type": "binary",
+      "finalValue": []
+    }
+  },
+  "uncertainVariables": {
+    "c": {
+      "dimensions": [ 8 ]
+    },
+    "d": {
+      "dimensions": [ 8 ],
+      "formula": "PsiBinomial(1, 0.9)"
+    },
+    "c[1]": {
+      "formula": "PsiTriangular(400000, 500000, 900000)"
+    },
+    "c[2]": {
+      "formula": "PsiTriangular(500000, 750000, 1250000)"
+    },
+    "c[3]": {
+      "formula": "PsiTriangular(500000, 1000000,1500000)"
+    },
+    "c[4]": {
+      "formula": "PsiTriangular(400000, 600000, 900000)"
+    },
+    "c[5]": {
+      "formula": "PsiTriangular(250000, 500000, 750000)"
+    },
+    "c[6]": {
+      "formula": "PsiTriangular(300000, 500000, 600000)"
+    },
+    "c[7]": {
+      "formula": "PsiTriangular(200000, 450000, 700000)"
+    },
+    "c[8]": {
+      "formula": "PsiTriangular(400000, 500000, 700000)"
+    }
+  },
+  "formulas": {
+    "f": {
+      "value": [ 325000, 450000, 550000, 300000, 150000, 250000, 150000, 325000 ]
+    },
+    "cash": {
+      "formula": "sumproduct(c * d - f, x)"
+    }
+  },
+  "constraints": {
+    "invest": {
+      "formula": "sumproduct(f, x)",
+      "upper": 1500000
+    }
+  },
+  "objective": {
+    "total": {
+      "type": "maximize",
+      "formula": "cash",
+      "chanceType": "ExpVal",
+      "finalValue": []
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+{
+  "modelName": "UGProjectSelect2Example",
+  "modelDescription": "RASON Stochastic Optimization Model: Robust Counterpart:  This example is a Stochastic LP. This example is not directly discussed in the Defining Your Stochastic Optimization Model. Rather, this example simply uses the 3rd and final method to solve a stochastic LP. Recall that UGProjectSelect0 solved via simulation optimization and UGProjectSelect1 solved via stochastic transformation using the deterministic method. This example uses the stochastic transformation using the robust counterpart method. To use robust counterpart, simply enter 'robustCounterpart' for 'transformStochastic' in 'modelSettings'. The remainder of the model remains unchanged from UGProjectSelect1.",
+  "modelType": "optimization",
+  "modelSettings": {
+    "comment": "To use the robust counterpart method, simply enter 'transformStochastic':'robustCounterpart'.",
+    "transformStochastic": "robustCounterpart",
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "randomSeed": 1
+  },
+  "variables": {
+    "x": {
+      "dimensions": [ 8 ],
+      "type": "binary",
+      "finalValue": []
+    }
+  },
+  "uncertainVariables": {
+    "c": {
+      "dimensions": [ 8 ]
+    },
+    "d": {
+      "dimensions": [ 8 ],
+      "formula": "PsiBinomial(1, 0.9)"
+    },
+    "c[1]": {
+      "formula": "PsiTriangular(400000, 500000, 900000)"
+    },
+    "c[2]": {
+      "formula": "PsiTriangular(500000, 750000, 1250000)"
+    },
+    "c[3]": {
+      "formula": "PsiTriangular(500000, 1000000,1500000)"
+    },
+    "c[4]": {
+      "formula": "PsiTriangular(400000, 600000, 900000)"
+    },
+    "c[5]": {
+      "formula": "PsiTriangular(250000, 500000, 750000)"
+    },
+    "c[6]": {
+      "formula": "PsiTriangular(300000, 500000, 600000)"
+    },
+    "c[7]": {
+      "formula": "PsiTriangular(200000, 450000, 700000)"
+    },
+    "c[8]": {
+      "formula": "PsiTriangular(400000, 500000, 700000)"
+    }
+  },
+  "formulas": {
+    "f": {
+      "value": [ 325000, 450000, 550000, 300000, 150000, 250000, 150000, 325000 ]
+    },
+    "cash": {
+      "formula": "sumproduct(c * d - f, x)"
+    }
+  },
+  "constraints": {
+    "invest": {
+      "formula": "sumproduct(f, x)",
+      "upper": 1500000
+    }
+  },
+  "objective": {
+    "total": {
+      "type": "maximize",
+      "formula": "cash",
+      "chanceType": "ExpVal",
+      "finalValue": []
+    }
+  }
+}

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

@@ -0,0 +1,62 @@
+{
+  "modelName": "UGYieldManagement1Example",
+  "modelDescription": "RASON Single Simulation Example: This model is discussed in the chapter, Defining a Simulation Model within the Rason User Guide (downloadable from the Help tab). This example is a simple airline revenue management model, also known as a yield management model. the subsequentexamples, UGYieldManagement2 and UGYieldManagement3, will transform this simple simulation model, first into a parameterized model in the next example and then a simulation optimization model in the third example.  The example files that are discussed are:  UGYieldManagement1.json (a simple simulation model), UGYieldManagement2.json (a model with multiple parameterized simulations) and UGYieldManagement3.json (a simulation optimization model). You can open each example by clicking RASON Examples on the Editor page, then Example models discussed in RASON User Guide.",
+  "comment": "The model depicts a hypothetical airline flight from San Francisco to Seattle. The flight has 100 seats, and tickets are $200 per seat. Some passengers who purchase tickets are 'no-shows' whose seats will be empty; in this example we assume that such passengers receive a refund of 50% of their purchase price. To utilize their 'perishable inventory' of seats, the airline would like to sell more than 100 tickets for each flight. But we assume that Federal regulations require that any ticketed passenger who is unable to board the flight due to overbooking is entitled to compensation of 125% of the ticket price. The airline would like to know how much revenue it will generate from each flight, less refunds for no-shows and compensation for 'bumped' passengers. To perform a single simulation (with 1,000 Monte Carlo trials) using click POST rason.net/api/model to POST the model to the RASON Server and then POST rason.net/api/model/{nameorid}/simulate to run the simulation.",
+  "modelType": "simulation",
+  "modelSettings": {
+    "comment": "Sets the number of simulations to 1, the default, and the number of trials to 1000, also the default.",
+    "numSimulations": 1,
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "randomSeed": 1
+  },
+  "data": {
+    "comment": "The data section holds constant values used in the model such as ticket price, plane capacity, number of tickets sold, the refund percentage for a no show passenger and the refund percentage for any 'bumped' passengers. ",
+    "price": {
+      "comment": "ticket price",
+      "value": 200
+    },
+    "capacity": {
+      "comment": "number of seats on the plane",
+      "value": 100
+    },
+    "sold": {
+      "comment": "number of tickets sold",
+      "value": 110
+    },
+    "refund_no_shows": {
+      "comment": "refund percentage for a passenger who misses their flight.",
+      "value": 0.5
+    },
+    "refund_overbook": {
+      "comment": "refund percentage for any 'bumped' passengers",
+      "value": 1.25
+    }
+  },
+  "uncertainVariables": {
+    "no_shows": {
+      "comment": "The uncertain quantity in this model is the number of no-shows; hence we should model this with an uncertain variable. The number of no-shows will depend on the number of tickets sold. After some research, it is decided to use a LogNormal distribution to model the number of no-shows. The expected value of this uncertain variable will be returned in the results, due to the presence of the 'mean' property.",
+      "formula": "PsiLogNormal(0.1*sold, 0.06*sold)",
+      "mean": []
+    }
+  },
+  "formulas": {
+    "comment": "Within formulas, the formula for show_ups contains the ROUND(no_shows,0) function to ensure that the number of no-shows is an integer value – and this is used to compute the net revenue in the revenue uncertain function.",
+    "show_ups": {
+      "formula": "sold - Round(no_shows, 0)"
+    },
+    "overbook": {
+      "formula": "Max(0, show_ups - capacity)"
+    }
+  },
+  "uncertainFunctions": {
+    "revenue": {
+      "comment": "The airline would like to know how much revenue it will generate from each flight, less refunds for no-shows and compensation for 'bumped' passengers. This net revenue amount is calculated in revenue within uncertainFunctions, for any specific number of tickets sold (110 above) and number of no-shows (5 above). The expected value of this uncertain function, along with the function's percentiles and all 1000 trial values will be returned in the results, due to the presence of the 'mean', percentiles and trials properties, respectively.",
+      "formula": "price*(sold - refund_no_shows*Round(no_shows, 0) - refund_overbook*overbook)",
+      "mean": [],
+      "percentiles": [],
+      "trials": []
+    }
+  }
+}

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

@@ -0,0 +1,62 @@
+{
+  "modelName": "UGYieldManagement2Example",
+  "modelDescription": "RASON Parametric Simulation Model: In the simulation results for the original model, UGYieldMangement1, the mean or expected net revenue is about $20,000. The 10th percentile equals 19,950, which infers that if 110 tickets are sold, the revenue earned is almost as much as a full flight 90% of the time. (Full flight revenue = 100*200) This leads to the question, should we sell more tickets? How many tickets can we sell in order to increase revenue? One could simply enter various values for 'sold', each time recording the revenue value to see if it increases or decreases. However, entering the parameter PsiSimParam() allows multiple values to be entered and simulations performed, all at once!",
+  "comment": "In this example, a simulation parameter has been entered into a new section, 'parameters', and the number of simulations (numSimulations) has been set to 41 within 'modelSettings'. RASON will perform 41 simulations. In the first simulation, a value of 110 will be used for 'sold'. In the 2nd simulation, a value of 111 will be used for sold, in the third, a value of 112, etc...all the way to the 41st simulation which will use 150 for 'sold' ",
+  "modelType": "simulation",
+  "modelSettings": {
+    "comment": "Set the number of simulations to 41 to run 41 simulations, each with a different value for 'sold'. To see the results of just one of the simulations, use the simulationIndex property, for example 'simulationIndex':5 will return results of (only) the 5th simulation.",
+    "numSimulations": 41,
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "randomSeed": 1
+  },
+  "parameters": {
+    "comment": "The PsiSimParam will vary the value for 'sold' each time a simulation is performed. Each value of the PsiSimParam will be returned in the results due to the presence of the finalValue property.",
+    "sold": {
+      "formula": "PsiSimParam(110,150)",
+      "finalValue": []
+    }
+  },
+  "data": {
+    "comment": "The data section remains unchanged from UGYieldManagement1, except sold has been deleted as it now appears in the parameters section above.",
+    "price": {
+      "value": 200
+    },
+    "capacity": {
+      "value": 100
+    },
+    "refund_no_shows": {
+      "value": 0.5
+    },
+    "refund_overbook": {
+      "value": 1.25
+    }
+  },
+  "uncertainVariables": {
+    "comment": "This section remains unchanged from UGYieldManagement1.",
+    "no_shows": {
+      "formula": "PsiLogNormal(0.1*sold, 0.06*sold)",
+      "mean": []
+    }
+  },
+  "formulas": {
+    "comment": "This section remains unchanged from UGYieldManagement1.",
+    "show_ups": {
+      "formula": "sold - Round(no_shows, 0)"
+    },
+    "overbook": {
+      "formula": "Max(0, show_ups - capacity)"
+    }
+  },
+  "uncertainFunctions": {
+    "comment": "This section remains unchanged from UGYieldManagement1.",
+    "revenue": {
+      "formula": "price*(sold - refund_no_shows*Round(no_shows, 0) - refund_overbook*overbook)",
+      "mean": [],
+      "percentiles": [],
+      "trials": []
+    }
+  }
+}
+    

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

@@ -0,0 +1,64 @@
+{
+  "modelName": "UGYieldManagement3Example",
+  "modelDescription": "RASON Simulation Optimization Model: Running multiple parameterized simulations in UGYieldManagement2, and examining the results has given us a good deal of information about the behavior of this simulation model. However, if we take just a few more steps we can answer the question, 'How many tickets should we sell to realize the maximum expected net revenue?' By changing 'sold' from a simulation parameter to a decision variable, we can setup a simulation optimization model. See the Defining Your Stochastic Optimization chapter within the RASON User Guide for a complete discussion of this example and also the previous examples UGYieldManagement 1 and 2.",
+  "comment": "Change the modelType property to 'optimization'. If left at 'modelType':'simulation' as in UGYieldManagement 1 and 2, only a simulation will be performed, not a simulation optimization.",
+  "modelType": "optimization",
+  "modelSettings": {
+    "comment": "Replace numSimulations: 41 with simulationOptimization: True in modelSettings. Setting simulationOptimization to true will run a simulation optimization. The evolutionary engine must be selected in engineSettings below.",
+    "simulationOptimization": true,
+    "numTrials": 1000
+  },
+  "engineSettings": {
+    "comment": "In order to run a simulation optimization, you must set the engine to 'Evolutionary'. The random seed option is set to provide reproducible results.",
+    "engine": "Evolutionary",
+    "randomSeed": 1
+  },
+  "variables": {
+    "comment": "Replace parameters with variables and define sold as an integer variable (since we can't sell fractional tickets) with a lower bound of 0 (since we can't sell a negative number of tickets). We are interested in the value of this variable in the solution, so we must ask for the finalValue to be returned in the Result.",
+    "sold": {
+      "lower": 0,
+      "upper": 500,
+      "type": "integer",
+      "finalValue": []
+    }
+  },
+  "data": {
+    "comment": "The data section remains unchanged from UGYieldManagement 2.",
+    "price": {
+      "value": 200
+    },
+    "capacity": {
+      "value": 100
+    },
+    "refund_no_shows": {
+      "value": 0.5
+    },
+    "refund_overbook": {
+      "value": 1.25
+    }
+  },
+  "uncertainVariables": {
+    "comment": "The uncertainVariables section remains unchanged from UGYieldManagement 2.",
+    "no_shows": {
+      "formula": "PsiLogNormal(0.1*sold, 0.06*sold)"
+    }
+  },
+  "formulas": {
+    "comment": "The formulas section remains unchanged from UGYieldManagement 2.",
+    "show_ups": {
+      "formula": "sold - Round(no_shows, 0)"
+    },
+    "overbook": {
+      "formula": "Max(0, show_ups - capacity)"
+    }
+  },
+  "objective": {
+    "comment": "The objective section remains unchanged from UGYieldManagement 2.",
+    "revenue": {
+      "formula": "price*(sold - refund_no_shows*Round(no_shows, 0) - refund_overbook*overbook)",
+      "chanceType": "ExpVal",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}