@frontlinesystems/rason-mcp-server 2026.5.0 → 2026.5.1

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

@@ -1,51 +1,51 @@
-{
-  "modelName": "UGForecastSimExample",
-  "modelDescription": "RASON Forecast Simulation Example - This example appears in the Defining Your Simulation MOdel chapter in the RASON User Guide. Imagine that you are the sales manager for a company that is planning to introduce a new product. You need to estimate the first year profit from this product (which depends on the number of unit sales), the price per unit sold, the unit manufacturing cost, and any fixed costs or overhead. You have been advised that the unit manufacturing cost will range between $4.50 and $8.50, with a most-likely cost of $6.50. Based on your market research, you believe it is equally likely that the market demand will be Slow, OK, or Hot.",
-  "modelType": "simulation",
-  "comment": "When creating any RASON model, our model definition begins with a simple open bracket.  Next we see three optional, but strongly recommended, high level properties, modelName, modelDescription and modelType.  ModelName assigns a name to the model for easy retrieval later, modelDescription gives a short description of the problem and modelType informs the RASON Server that this model is a simulation model.",
-  "uncertainVariables": {
-    "comment": "There are two uncertain variables in this model, marketType and unitCost. The unit cost uses the PsiTriangular distribution to model the manufacturing cost while marketType uses the PsiIntUniform distribution to model the market demand. Since these are distributions, there will be 1000 values (the default setting for number of trials) returned for both marketType and unitCost.",
-    "marketType": {
-      "comment": "Since there are equal chances that the market will be Slow, OK, or Hot, we want to create an uncertain variable that selects among these three possibilities, by drawing a random number – say 1, 2 or 3 – with equal probability. We can do this easily in the RASON modeling language using an integer uniform probability distribution or PsiIntUniform(). Sales Volume and Selling Price will both be based on this uncertain variable. See the marketType uncertain variable in below.  A sample drawn from a discrete distribution is always one of a set of discrete values, such as integer values.  For more information on this distribution, see the RASON Reference Guide, downloadable from the Help tab. ",
-      "formula": "PsiIntUniform(1,3)"
-    },
-    "unitCost": {
-      "comment": "There are not just three, but many possible values for this variable: It can be anywhere from $4.50 to $8.50, with a most likely cost of $6.50. A crude but effective way to model this is to use a triangular distribution. The RASON modeling language provides a function called PsiTriangular() for this distribution (see the unitCost uncertain variable below).  For more information on this distribution, see the RASON Reference Guide, downloadable from the Help tab.",
-      "formula": "PsiTriangular(4.5, 6.5, 8.5)"
-    }
-  },
-  "formulas": {
-    "comment": "The salesVolume and sellingPrice formulas use the value of the PsiIntUniform distribution to determine which market (Slow, OK, or Hot) is selected per trial. If marketType equals 1, the Sales Volume and Selling Price are 50,000 and $11, if marketType equals 2, the Sales Volume and Selling Price are 75,000 and $10 and if marketType equals 3, the Sales Volume and Selling Price are 100,000 and $8.",
-    "salesVolume": {
-      "comment": "Calculates the sales volume based on the marketType uncertain variable. Since salesVolume is based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
-      "formula": "if(marketType = 1, 50000, if(marketType = 2, 75000, if(marketType = 3, 100000)))"
-    },
-    "sellingPrice": {
-      "comment": "Calculates the product selling price based on the marketType uncertain variable. Since salesVolume is based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
-      "formula": "if(marketType = 1, 11, if(marketType = 2, 10, if(marketType = 3, 8)))"
-    },
-    "grossSales": {
-      "comment": "Calculates gross sales as a product of selling price and sales volume. Since grossSales is indirectly based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
-      "formula": "sellingPrice * salesVolume"
-    },
-    "totalCosts": {
-      "comment": "Calculates the total costs as a product of sales volume and unit cost. Since totalCosts is indirectly based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
-      "formula": "salesVolume * unitCost"
-    }
-  },
-  "data": {
-    "comment": "The data section holds the constant fixedCosts, which equals $120,000.",
-    "fixedCosts": {
-      "value": 120000
-    }
-  },
-  "uncertainFunctions": {
-    "comment": "The last section, uncertainFunctions, calculates the Net Profit by subtracting totalCosts and fixedCosts from grossSales.  Since we want to know the expected (or average) net profit, we ask for the mean in our result. Note that the result of the formula ('grossSales - totalCosts - fixedCosts') is 1,000 scenarios or trials, rather than a single value.  The mean that will be returned in the result will be the true average of Net Profit across 1,000 or more scenarios or trials – not a single calculation from average values of the inputs. We could have asked for additional result measures for netProfit such as the minimum function value, maximum function value, standard deviation, variance, median, mode, etc.   One, several, or all can be returned in a result. View them in the results under netProfit_statistics. View all 1000 trials under netProfit_trials and view the percentile values under netProfit_percentiles. For a complete list of measures that may be returned please see the chapter RASON Model Components in the RASON Reference Guide.",
-    "netProfit": {
-      "formula": "grossSales - totalCosts - fixedCosts",
-      "mean": [],
-      "percentiles": [],
-      "trials": []
-    }
-  }
+{
+  "modelName": "UGForecastSimExample",
+  "modelDescription": "RASON Forecast Simulation Example - This example appears in the Defining Your Simulation MOdel chapter in the RASON User Guide. Imagine that you are the sales manager for a company that is planning to introduce a new product. You need to estimate the first year profit from this product (which depends on the number of unit sales), the price per unit sold, the unit manufacturing cost, and any fixed costs or overhead. You have been advised that the unit manufacturing cost will range between $4.50 and $8.50, with a most-likely cost of $6.50. Based on your market research, you believe it is equally likely that the market demand will be Slow, OK, or Hot.",
+  "modelType": "simulation",
+  "comment": "When creating any RASON model, our model definition begins with a simple open bracket.  Next we see three optional, but strongly recommended, high level properties, modelName, modelDescription and modelType.  ModelName assigns a name to the model for easy retrieval later, modelDescription gives a short description of the problem and modelType informs the RASON Server that this model is a simulation model.",
+  "uncertainVariables": {
+    "comment": "There are two uncertain variables in this model, marketType and unitCost. The unit cost uses the PsiTriangular distribution to model the manufacturing cost while marketType uses the PsiIntUniform distribution to model the market demand. Since these are distributions, there will be 1000 values (the default setting for number of trials) returned for both marketType and unitCost.",
+    "marketType": {
+      "comment": "Since there are equal chances that the market will be Slow, OK, or Hot, we want to create an uncertain variable that selects among these three possibilities, by drawing a random number – say 1, 2 or 3 – with equal probability. We can do this easily in the RASON modeling language using an integer uniform probability distribution or PsiIntUniform(). Sales Volume and Selling Price will both be based on this uncertain variable. See the marketType uncertain variable in below.  A sample drawn from a discrete distribution is always one of a set of discrete values, such as integer values.  For more information on this distribution, see the RASON Reference Guide, downloadable from the Help tab. ",
+      "formula": "PsiIntUniform(1,3)"
+    },
+    "unitCost": {
+      "comment": "There are not just three, but many possible values for this variable: It can be anywhere from $4.50 to $8.50, with a most likely cost of $6.50. A crude but effective way to model this is to use a triangular distribution. The RASON modeling language provides a function called PsiTriangular() for this distribution (see the unitCost uncertain variable below).  For more information on this distribution, see the RASON Reference Guide, downloadable from the Help tab.",
+      "formula": "PsiTriangular(4.5, 6.5, 8.5)"
+    }
+  },
+  "formulas": {
+    "comment": "The salesVolume and sellingPrice formulas use the value of the PsiIntUniform distribution to determine which market (Slow, OK, or Hot) is selected per trial. If marketType equals 1, the Sales Volume and Selling Price are 50,000 and $11, if marketType equals 2, the Sales Volume and Selling Price are 75,000 and $10 and if marketType equals 3, the Sales Volume and Selling Price are 100,000 and $8.",
+    "salesVolume": {
+      "comment": "Calculates the sales volume based on the marketType uncertain variable. Since salesVolume is based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
+      "formula": "if(marketType = 1, 50000, if(marketType = 2, 75000, if(marketType = 3, 100000)))"
+    },
+    "sellingPrice": {
+      "comment": "Calculates the product selling price based on the marketType uncertain variable. Since salesVolume is based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
+      "formula": "if(marketType = 1, 11, if(marketType = 2, 10, if(marketType = 3, 8)))"
+    },
+    "grossSales": {
+      "comment": "Calculates gross sales as a product of selling price and sales volume. Since grossSales is indirectly based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
+      "formula": "sellingPrice * salesVolume"
+    },
+    "totalCosts": {
+      "comment": "Calculates the total costs as a product of sales volume and unit cost. Since totalCosts is indirectly based on the marketType uncertain variable, there will be 1000 values returned, not just a single value.",
+      "formula": "salesVolume * unitCost"
+    }
+  },
+  "data": {
+    "comment": "The data section holds the constant fixedCosts, which equals $120,000.",
+    "fixedCosts": {
+      "value": 120000
+    }
+  },
+  "uncertainFunctions": {
+    "comment": "The last section, uncertainFunctions, calculates the Net Profit by subtracting totalCosts and fixedCosts from grossSales.  Since we want to know the expected (or average) net profit, we ask for the mean in our result. Note that the result of the formula ('grossSales - totalCosts - fixedCosts') is 1,000 scenarios or trials, rather than a single value.  The mean that will be returned in the result will be the true average of Net Profit across 1,000 or more scenarios or trials – not a single calculation from average values of the inputs. We could have asked for additional result measures for netProfit such as the minimum function value, maximum function value, standard deviation, variance, median, mode, etc.   One, several, or all can be returned in a result. View them in the results under netProfit_statistics. View all 1000 trials under netProfit_trials and view the percentile values under netProfit_percentiles. For a complete list of measures that may be returned please see the chapter RASON Model Components in the RASON Reference Guide.",
+    "netProfit": {
+      "formula": "grossSales - totalCosts - fixedCosts",
+      "mean": [],
+      "percentiles": [],
+      "trials": []
+    }
+  }
 }

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

@@ -1,49 +1,49 @@
-{
-  "modelName": "UGProductMix1_BasicLinearModel",
-  "modelDescription": "RASON Product Mix Example: UGProductMix1 Example - This example is discussed in the Defining Your Optimization Model chapter. Assume a company manufatures TVs, stereos and speakers, using a common parts inventory of chassis, LOCD screens, speakers power supplies and various internal electronics.  Parts are in limited supply. This model works well for the business situation initially described, with exactly three products and five types of parts but it's not very flexible. What if more products were added and more parts were required?  In the next example UGProductMix2Example, the model will be generalized so it can handle different numbers of products and parts.",
-  "modelType": "optimization",
-  "variables": {
-    "comment": "In variables, a column vector x of size 3 is defined (x[1], x[2] and x[3]) to hold the number of products to produce. These are the decision variables. The dimensions of an array can be explicitly defined by the dimensions property.  However, in the absence of the dimensions property (as in this example), the  'value', 'lower', or 'upper' properties can implicitly define the shape of the array, as is shown here using the 'lower' property. The empty array, finalValue[] tells RASON that we want the results from solving to include the final values of each variable.",
-    "x": {
-      "comment": "The decision variables are the number of products of each type to build: x1 for TV sets, x2 for stereos and x3 for speakers. Since a negative number of parts can not be manufactured, a lower bound of 0 is supplied for each variable using the 'lower' property. See the variable final values in the result under x.",
-      "lower": [ 0, 0, 0 ],
-      "finalValue": []
-    }
-  },
-  "constraints": {
-    "comment": "Building each product requires a certain number of parts of each type. For example, TV sets and stereos each require one chassis, but speakers don't use one. The number of parts used depends on the mix of products built (the left hand side of each constraint), and we have a limited number of parts of each type on hand (the corresponding constraint right hand side). Since the number of products built must be nonnegative, we also have the constraints x1, x2, x3 >= 0. Note that terms like 0 x3 are included purely to show the structure of the model – they can be either omitted or included in your data. The 5 constraints are calculated in Constraints by multiplying the decision variables (x[1], x[2] and x[3]) by the number of parts required. The number of parts used must be less than or equal to the number of parts in inventory, so the upper bound for our first constraint is:  x[1] * 1 + x[2] * 1 + x[3] * 0 <= 450.  The other constraints are similar.  Note that both the upper and lower properties only support constant values, no formulas.   ",
-    "chassisUsed": {
-      "comment": "#Tvs * 1 + #Stereos * 1 + #Speakers * 0 - Each TV and stereo require 1 chassis each. There are 450 chassis on hand in inventory. ",
-      "formula": "x[1] * 1 + x[2] * 1 + x[3] * 0",
-      "upper": 450
-    },
-    "screensUsed": {
-      "comment": "#Tvs * 1 + #Stereos * 0 + #Speakers * 0 - Each TV requires screens chassis each. There are 250 screens on hand in inventory. ",
-      "formula": "x[1] * 1 + x[2] * 0 + x[3] * 0",
-      "upper": 250
-    },
-    "speakersUsed": {
-      "comment": "#Tvs * 2 + #Stereos * 2 + #Speakers * 1 - Each TV and stereo require 2 speakers each; a speaker only requires 1 speaker part. There are 800 speakers on hand in inventory. ",
-      "formula": "x[1] * 2 + x[2] * 2 + x[3] * 1",
-      "upper": 800
-    },
-    "powerUsed": {
-      "comment": "#Tvs * 1 + #Stereos * 1 + #Speakers * 0 - Each TV and stereo require 1 power cord each. There are 450 power cords on hand in inventory. ",
-      "formula": "x[1] * 1 + x[2] * 1 + x[3] * 0",
-      "upper": 450
-    },
-    "electronicsUsed": {
-      "comment": "#Tvs * 2 + #Stereos * 1 + #Speakers * 1 - Each TV requires 2 electronic components and each stero and speaker require 1. There are 600 chassis on hand in inventory. ",
-      "formula": "x[1] * 2 + x[2] * 1 + x[3] * 1",
-      "upper": 600
-    }
-  },
-  "objective": {
-    "obj": {
-      "comment": "There is a fixed profit per unit for each product, so the objective function (the quantity we want to maximize) is: Maximize 75 x1 + 50 x2 + 35 x3 (Profit). See the objective value in the results under obj.",
-      "type": "maximize",
-      "formula": "x[1] * 75 + x[2] * 50 + x[3] * 35",
-      "finalValue": []
-    }
-  }
+{
+  "modelName": "UGProductMix1_BasicLinearModel",
+  "modelDescription": "RASON Product Mix Example: UGProductMix1 Example - This example is discussed in the Defining Your Optimization Model chapter. Assume a company manufatures TVs, stereos and speakers, using a common parts inventory of chassis, LOCD screens, speakers power supplies and various internal electronics.  Parts are in limited supply. This model works well for the business situation initially described, with exactly three products and five types of parts but it's not very flexible. What if more products were added and more parts were required?  In the next example UGProductMix2Example, the model will be generalized so it can handle different numbers of products and parts.",
+  "modelType": "optimization",
+  "variables": {
+    "comment": "In variables, a column vector x of size 3 is defined (x[1], x[2] and x[3]) to hold the number of products to produce. These are the decision variables. The dimensions of an array can be explicitly defined by the dimensions property.  However, in the absence of the dimensions property (as in this example), the  'value', 'lower', or 'upper' properties can implicitly define the shape of the array, as is shown here using the 'lower' property. The empty array, finalValue[] tells RASON that we want the results from solving to include the final values of each variable.",
+    "x": {
+      "comment": "The decision variables are the number of products of each type to build: x1 for TV sets, x2 for stereos and x3 for speakers. Since a negative number of parts can not be manufactured, a lower bound of 0 is supplied for each variable using the 'lower' property. See the variable final values in the result under x.",
+      "lower": [ 0, 0, 0 ],
+      "finalValue": []
+    }
+  },
+  "constraints": {
+    "comment": "Building each product requires a certain number of parts of each type. For example, TV sets and stereos each require one chassis, but speakers don't use one. The number of parts used depends on the mix of products built (the left hand side of each constraint), and we have a limited number of parts of each type on hand (the corresponding constraint right hand side). Since the number of products built must be nonnegative, we also have the constraints x1, x2, x3 >= 0. Note that terms like 0 x3 are included purely to show the structure of the model – they can be either omitted or included in your data. The 5 constraints are calculated in Constraints by multiplying the decision variables (x[1], x[2] and x[3]) by the number of parts required. The number of parts used must be less than or equal to the number of parts in inventory, so the upper bound for our first constraint is:  x[1] * 1 + x[2] * 1 + x[3] * 0 <= 450.  The other constraints are similar.  Note that both the upper and lower properties only support constant values, no formulas.   ",
+    "chassisUsed": {
+      "comment": "#Tvs * 1 + #Stereos * 1 + #Speakers * 0 - Each TV and stereo require 1 chassis each. There are 450 chassis on hand in inventory. ",
+      "formula": "x[1] * 1 + x[2] * 1 + x[3] * 0",
+      "upper": 450
+    },
+    "screensUsed": {
+      "comment": "#Tvs * 1 + #Stereos * 0 + #Speakers * 0 - Each TV requires screens chassis each. There are 250 screens on hand in inventory. ",
+      "formula": "x[1] * 1 + x[2] * 0 + x[3] * 0",
+      "upper": 250
+    },
+    "speakersUsed": {
+      "comment": "#Tvs * 2 + #Stereos * 2 + #Speakers * 1 - Each TV and stereo require 2 speakers each; a speaker only requires 1 speaker part. There are 800 speakers on hand in inventory. ",
+      "formula": "x[1] * 2 + x[2] * 2 + x[3] * 1",
+      "upper": 800
+    },
+    "powerUsed": {
+      "comment": "#Tvs * 1 + #Stereos * 1 + #Speakers * 0 - Each TV and stereo require 1 power cord each. There are 450 power cords on hand in inventory. ",
+      "formula": "x[1] * 1 + x[2] * 1 + x[3] * 0",
+      "upper": 450
+    },
+    "electronicsUsed": {
+      "comment": "#Tvs * 2 + #Stereos * 1 + #Speakers * 1 - Each TV requires 2 electronic components and each stero and speaker require 1. There are 600 chassis on hand in inventory. ",
+      "formula": "x[1] * 2 + x[2] * 1 + x[3] * 1",
+      "upper": 600
+    }
+  },
+  "objective": {
+    "obj": {
+      "comment": "There is a fixed profit per unit for each product, so the objective function (the quantity we want to maximize) is: Maximize 75 x1 + 50 x2 + 35 x3 (Profit). See the objective value in the results under obj.",
+      "type": "maximize",
+      "formula": "x[1] * 75 + x[2] * 50 + x[3] * 35",
+      "finalValue": []
+    }
+  }
 }

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

@@ -1,49 +1,49 @@
-{
-  "modelName": "UGProductMix2_ImprovedLinearModel",
-  "modelDescription": "RASON Product Mix Example: UGProductMix2 Example - This example is discussed in the Defining Your Optimization chapter within the RASON User Guide. See 'The Improve Model' section within the chapter. One way to make the original product mix model (UGProductMix1Example) more flexible is to use RASON's built-in functions that operate on all the elements of an array at once, treating it as a vector or matrix. With this version of the model, if the number of parts or products are increased or decreased, you will need to adjust the size of your arrays, but no changes will be needed for the constraints formula which can sometimes be the hardest part of the model to define.",
-  "modelType": "optimization",
-  "variables": {
-    "comment": "In the variables section, we again define a column vector x of size  3 but this time the dimensions property is used to explicitly define the size of the array.  As a result, we can pass a single value to the lower property applying a lower bound of 0 to all three elements of the x array.  Again, the empty array, finalValue:[] tells the RASON system that you want the results from solving to include the final values of each variable.",
-    "X": {
-      "dimensions": [ 3 ],
-      "lower": 0,
-      "finalValue": []
-    }
-  },
-  "data": {
-    "profit": {
-      "dimensions": [ 3, 1 ],
-      "value": [ 75, 50, 35 ],
-      "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": "In the original example (UGProductMix1Example), the 5 constraints were calculated using explicit formulas such as 'x[1] * 1 + x[2] * 1 + x[3] * 0'. In this model, three arrays are created in the 'data' section to hold the information for the model: profits (to hold the profit margin of each product), inventory (to hold the available inventory) and parts (a matrix holding the part requirements for each product).  Note:  The RASON Language Interpreter currently ONLY supports constants, a name with constant values, or a named array of constants for the lower and upper arguments.",
-    "numUsed": {
-      "comment": "The MMULT function in the num_used constraint multiplies the matrix parts (with 5 rows and 3 columns) by the column vector x.  The product of this multiplication is a column vector with 5 rows which must be less than the column vector, inventory.",
-      "dimensions": [ 5 ],
-      "formula": "MMULT(parts, X)",
-      "upper": "inventory"
-    }
-  },
-  "objective": {
-    "total": {
-      "type": "maximize",
-      "formula": "sumproduct(X, profit)",
-      "finalValue": []
-    }
-  }
+{
+  "modelName": "UGProductMix2_ImprovedLinearModel",
+  "modelDescription": "RASON Product Mix Example: UGProductMix2 Example - This example is discussed in the Defining Your Optimization chapter within the RASON User Guide. See 'The Improve Model' section within the chapter. One way to make the original product mix model (UGProductMix1Example) more flexible is to use RASON's built-in functions that operate on all the elements of an array at once, treating it as a vector or matrix. With this version of the model, if the number of parts or products are increased or decreased, you will need to adjust the size of your arrays, but no changes will be needed for the constraints formula which can sometimes be the hardest part of the model to define.",
+  "modelType": "optimization",
+  "variables": {
+    "comment": "In the variables section, we again define a column vector x of size  3 but this time the dimensions property is used to explicitly define the size of the array.  As a result, we can pass a single value to the lower property applying a lower bound of 0 to all three elements of the x array.  Again, the empty array, finalValue:[] tells the RASON system that you want the results from solving to include the final values of each variable.",
+    "X": {
+      "dimensions": [ 3 ],
+      "lower": 0,
+      "finalValue": []
+    }
+  },
+  "data": {
+    "profit": {
+      "dimensions": [ 3, 1 ],
+      "value": [ 75, 50, 35 ],
+      "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": "In the original example (UGProductMix1Example), the 5 constraints were calculated using explicit formulas such as 'x[1] * 1 + x[2] * 1 + x[3] * 0'. In this model, three arrays are created in the 'data' section to hold the information for the model: profits (to hold the profit margin of each product), inventory (to hold the available inventory) and parts (a matrix holding the part requirements for each product).  Note:  The RASON Language Interpreter currently ONLY supports constants, a name with constant values, or a named array of constants for the lower and upper arguments.",
+    "numUsed": {
+      "comment": "The MMULT function in the num_used constraint multiplies the matrix parts (with 5 rows and 3 columns) by the column vector x.  The product of this multiplication is a column vector with 5 rows which must be less than the column vector, inventory.",
+      "dimensions": [ 5 ],
+      "formula": "MMULT(parts, X)",
+      "upper": "inventory"
+    }
+  },
+  "objective": {
+    "total": {
+      "type": "maximize",
+      "formula": "sumproduct(X, profit)",
+      "finalValue": []
+    }
+  }
 }

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

@@ -1,68 +1,68 @@
-{
-    "modelName": "UGProductMixTable1",
-    "modelDescription": "RASON Product Mix Example:  Arrays in the RASON Modeling language are limited to 2-dimensions. If you require an array containing more than 2-dimensions, a table may be created. There are many advantages to using tables: 1. Tables may hold more than 2 dimensions, 2. A table result may be used in an indexed array formula, 3. A table can be sparse while an array is dense, 4. The evaluation of a table is less expensive (time consuming) than the evaluation of an array with more than 2 dimensions. In this example, the matrix above has been specified in line (within the RASON model) as the parts table.  This table contains 15 elements and is indexed using two dimensions:  part and prod. Note that this table is DENSE, meaning that zero values have been supplied as well as non-zero values. See the next example, UGProductMixTable2 to see an example of a SPARSE table, meaning only non-zero values are supplied. (To open this full example, and any example referenced in this guide, click the down array under RASON examples -- Examples discussed in the RASON User Guide.)",
-    "modelType": "optimization",
-    "data": {
-        "parts": {
-            "comment": "Notice that even though the parts table is listed horizontally in the RASON model, the table elements are stored in a vertical array.",
-            "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": {
-            "value": [75, 50, 35],
-            "binding": "get",
-            "finalValue": []
-        }
-    },
-    "variables": {
-        "x": {
-            "comment": "The x array, dimensioned using the index column prod, is an array of size 3 containing the decision values x[1], x[2] and x[3].  These are the number of each product to produce.",
-            "dimensions": ["prod"],
-            "value": 0,
-            "lower": 0,
-            "finalValue": []
-        }
-    },
-    "constraints": {
-        "comment": "Five constraints are formulated by 'slicing' the table to obtain the correct part data. For example, in the first constraint, c1, parts['chas', ] slices the table across the part chas which results in the elements:  1, 1, 0.  The second constraint, c2, slices the table across tube obtaining the elements 1, 0, 0.   Constraints c3, c4 and c5 are calculated in the same fashion.",
-        "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": "UGProductMixTable1",
+    "modelDescription": "RASON Product Mix Example:  Arrays in the RASON Modeling language are limited to 2-dimensions. If you require an array containing more than 2-dimensions, a table may be created. There are many advantages to using tables: 1. Tables may hold more than 2 dimensions, 2. A table result may be used in an indexed array formula, 3. A table can be sparse while an array is dense, 4. The evaluation of a table is less expensive (time consuming) than the evaluation of an array with more than 2 dimensions. In this example, the matrix above has been specified in line (within the RASON model) as the parts table.  This table contains 15 elements and is indexed using two dimensions:  part and prod. Note that this table is DENSE, meaning that zero values have been supplied as well as non-zero values. See the next example, UGProductMixTable2 to see an example of a SPARSE table, meaning only non-zero values are supplied. (To open this full example, and any example referenced in this guide, click the down array under RASON examples -- Examples discussed in the RASON User Guide.)",
+    "modelType": "optimization",
+    "data": {
+        "parts": {
+            "comment": "Notice that even though the parts table is listed horizontally in the RASON model, the table elements are stored in a vertical array.",
+            "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": {
+            "value": [75, 50, 35],
+            "binding": "get",
+            "finalValue": []
+        }
+    },
+    "variables": {
+        "x": {
+            "comment": "The x array, dimensioned using the index column prod, is an array of size 3 containing the decision values x[1], x[2] and x[3].  These are the number of each product to produce.",
+            "dimensions": ["prod"],
+            "value": 0,
+            "lower": 0,
+            "finalValue": []
+        }
+    },
+    "constraints": {
+        "comment": "Five constraints are formulated by 'slicing' the table to obtain the correct part data. For example, in the first constraint, c1, parts['chas', ] slices the table across the part chas which results in the elements:  1, 1, 0.  The second constraint, c2, slices the table across tube obtaining the elements 1, 0, 0.   Constraints c3, c4 and c5 are calculated in the same fashion.",
+        "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/UGProductMixTab2.json

@@ -1,77 +1,77 @@
-{
-    "modelName": "UGProductMixTable2",
-    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1, with two modifications. 1. Instead of passing a DENSE table, in which both zero and non-zero elements are passed in the parts table, this example passes a SPARSE table where only non-zero elements are passed. 2. This example model illustrates how to use an index set to dimension a table.  RASON uses index sets exclusively to dimension tables and arrays.",
-    "modelType": "optimization",
-    "indexSets": {
-        "comment": "The indexSets section is used exclusively to dimension tables and arrays. Typical mathematical programming models include multiple tables and arrays indexed over various index sets.  An index set should be created at the beginning of the model to establish a basis of order for each dimension appearing in a table or array.  Otherwise, the user will be required to keep track of and maintain the correct order of elements in all arrays and tables present in the model. An index set is always a 1-dimensional array and must be defined within the indexSets section of the RASON model. For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
-        "part": {
-            "comment": "The example code below creates the part ordered set. The part set contains five items (in order as entered):  chas, tube, cone, psup and elec. while the prod set contains 3 items:  tv, stereo and speakers.  For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
-            "value": ["chas", "tube", "cone", "psup", "elec"]
-        },
-        "prod": {
-            "comment": "The example code below creates the prod ordered set. The prod set contains 3 items:  tv, stereo and speakers.  For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
-            "value": ["tv", "stereo", "speaker"]
-        }
-    },
-    "data": {
-        "comment": "In the data section, an inline table object, parts, is created containing two index columns (parts and prods) and a value column. Since the index set prod exists, we can dimension the profits array according to this set in order to assign the correct profit values to the appropriate products. Likewise, we can dimension the inventory array according to the part set in order to assign the correct inventory level to each part. See UGProductMixTable3 for an illustration of the sort property.",
-        "parts": {
-            "comment": "Note that the order in which the table elements are entered is irrelevant since we are supplying both dimensions for each value. ",
-            "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],
-            "binding": "get",
-            "finalValue": []
-        },
-        "inventory": {
-            "dimensions": ["part"],
-            "value": [450, 250, 800, 450, 600],
-            "binding": "get",
-            "finalValue": []
-        }
-    },
-    "formulas": {
-        "comment": "Notice the use of the PIVOT function in the piv_parts formula. Recall that a table is stored as a vertical array.  The PIVOT function returns a 2-dimensional table (or a 1- dimensional table) of values with rows and columns assigned by the index columns in the table passed as the first argument. (The first argument passes the data.)  The second argument is the index column(s) to be assigned as column(s) in the PIVOT table. (These are the dimensions that will make up the columns of the table.) The third argument is the index column(s) to be assigned as row(s) in the PIVOT table. (These are the dimensions that will make up the rows of the table.) In this example, the table parts contains two index columns, parts and prods. The PIVOT function creates a 2-dimensional array of values by assigning the prod dimension (TV, Stereos and Speakers) as columns and the part dimension(chas, cone, elec, psup and tube) as rows. The result is a 5 x 3 matrix. Since piv_parts is now a 2-dimensional table, we can perform matrix multiplication using the MMULT (inherited from Excel) function to multiply this table by the variable array, x (which is also a vertical array).  The result of this operation is a vertical array of size 5 which must be less than the inventory array (enforced by the upper property of 0). ",
-        "piv_parts": {
-            "formula": "PIVOT(parts, { 'prod' }, { 'part' })"
-        }
-    },
-    "variables": {
-        "comment":"The x array is dimensioned using the prod index.",
-        "x": {
-            "dimensions": ["prod"],
-            "value": 0,
-            "lower": 0,
-            "finalValue": []
-        }
-    },
-    "constraints": {
-        "c": {
-            "dimensions": ["part"],
-            "formula": "MMULT(piv_parts, x) - inventory",
-            "upper": 0
-        }
-    },
-    "objective": {
-        "total": {
-            "formula": "sumproduct(x, profits)",
-            "type": "maximize",
-            "finalValue": []
-        }
-    }
+{
+    "modelName": "UGProductMixTable2",
+    "modelDescription": "RASON Product Mix Example: This example solves the same model as UGProductMixTable1, with two modifications. 1. Instead of passing a DENSE table, in which both zero and non-zero elements are passed in the parts table, this example passes a SPARSE table where only non-zero elements are passed. 2. This example model illustrates how to use an index set to dimension a table.  RASON uses index sets exclusively to dimension tables and arrays.",
+    "modelType": "optimization",
+    "indexSets": {
+        "comment": "The indexSets section is used exclusively to dimension tables and arrays. Typical mathematical programming models include multiple tables and arrays indexed over various index sets.  An index set should be created at the beginning of the model to establish a basis of order for each dimension appearing in a table or array.  Otherwise, the user will be required to keep track of and maintain the correct order of elements in all arrays and tables present in the model. An index set is always a 1-dimensional array and must be defined within the indexSets section of the RASON model. For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
+        "part": {
+            "comment": "The example code below creates the part ordered set. The part set contains five items (in order as entered):  chas, tube, cone, psup and elec. while the prod set contains 3 items:  tv, stereo and speakers.  For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
+            "value": ["chas", "tube", "cone", "psup", "elec"]
+        },
+        "prod": {
+            "comment": "The example code below creates the prod ordered set. The prod set contains 3 items:  tv, stereo and speakers.  For more information on index sets, see the Index Sets section within the RASON Reference Guide.",
+            "value": ["tv", "stereo", "speaker"]
+        }
+    },
+    "data": {
+        "comment": "In the data section, an inline table object, parts, is created containing two index columns (parts and prods) and a value column. Since the index set prod exists, we can dimension the profits array according to this set in order to assign the correct profit values to the appropriate products. Likewise, we can dimension the inventory array according to the part set in order to assign the correct inventory level to each part. See UGProductMixTable3 for an illustration of the sort property.",
+        "parts": {
+            "comment": "Note that the order in which the table elements are entered is irrelevant since we are supplying both dimensions for each value. ",
+            "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],
+            "binding": "get",
+            "finalValue": []
+        },
+        "inventory": {
+            "dimensions": ["part"],
+            "value": [450, 250, 800, 450, 600],
+            "binding": "get",
+            "finalValue": []
+        }
+    },
+    "formulas": {
+        "comment": "Notice the use of the PIVOT function in the piv_parts formula. Recall that a table is stored as a vertical array.  The PIVOT function returns a 2-dimensional table (or a 1- dimensional table) of values with rows and columns assigned by the index columns in the table passed as the first argument. (The first argument passes the data.)  The second argument is the index column(s) to be assigned as column(s) in the PIVOT table. (These are the dimensions that will make up the columns of the table.) The third argument is the index column(s) to be assigned as row(s) in the PIVOT table. (These are the dimensions that will make up the rows of the table.) In this example, the table parts contains two index columns, parts and prods. The PIVOT function creates a 2-dimensional array of values by assigning the prod dimension (TV, Stereos and Speakers) as columns and the part dimension(chas, cone, elec, psup and tube) as rows. The result is a 5 x 3 matrix. Since piv_parts is now a 2-dimensional table, we can perform matrix multiplication using the MMULT (inherited from Excel) function to multiply this table by the variable array, x (which is also a vertical array).  The result of this operation is a vertical array of size 5 which must be less than the inventory array (enforced by the upper property of 0). ",
+        "piv_parts": {
+            "formula": "PIVOT(parts, { 'prod' }, { 'part' })"
+        }
+    },
+    "variables": {
+        "comment":"The x array is dimensioned using the prod index.",
+        "x": {
+            "dimensions": ["prod"],
+            "value": 0,
+            "lower": 0,
+            "finalValue": []
+        }
+    },
+    "constraints": {
+        "c": {
+            "dimensions": ["part"],
+            "formula": "MMULT(piv_parts, x) - inventory",
+            "upper": 0
+        }
+    },
+    "objective": {
+        "total": {
+            "formula": "sumproduct(x, profits)",
+            "type": "maximize",
+            "finalValue": []
+        }
+    }
 }