@frontlinesystems/rason-mcp-server 2026.5.0

package/examples/rason-features/ReferenceGuide/RGProductMixExcel11.json

@@ -0,0 +1,117 @@
+{
+  "modelName": "RGProductMixExcel11",
+  "modelDescription": "RASON Conic Optimization Example: Example illustrates how to bind to an Excel sheet: In this example, data is imported from an Excel file. To perform the same steps when importing/exporting to an Excel file, you need to specify the cell address containing the dimensions to be imported and/or the cells to which the results should be exported.  In this example, the vars_data data source is again importing initial decision variable values and then exporting the final decision variable values to the same Excel workbook. See Data Sources within the RASON Reference Guide for more information. (Click Help tab to download.) ",
+  "modelType": "optimization",
+  "datasources": {
+    "comment": "Imports data from outside datasources.",
+    "parts_data": {
+      "comment": "Imports the parts data.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!G2:I12",
+      "indexCols": [ "parts", "prods" ],
+      "valueCols": [ "qty" ],
+      "direction": "import"
+    },
+    "invent_data": {
+      "comment": "Imports the inventory data.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!N2:O6",
+      "indexCols": [ "parts" ],
+      "valueCols": [ "inventory" ],
+      "direction": "import"
+    },
+    "profit_data": {
+      "comment": "Imports the profit per unit data.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!K2:L4",
+      "indexCols": [ "prods" ],
+      "valueCols": [ "profits" ],
+      "direction": "import"
+    },
+    "vars_data": {
+      "comment": "The vars_data data source performs a dual function by first importing the decision variable initial values from the Excel file ProductMixExcel.xlsx and then saving the final variable values back to that same file. The first property, type, specifies the type of file where the data is being imported/exported ('Excel'), the second property, connection, specifies the file name within quotes ('ResultVarsInit.txt') and the third property, selection, specifies where the final variable values will be appended ('Sheet1!Q2:R4'). We could pass a defined name here rather than a cell address. The fourth and fifth properties (indexCols and valueCols) are required for importing the initial variable values. The property, indexCols specifies the dimension(s) (or column(s)) to be imported and the property, valueCols, specifies the value column to be imported. Within variables, the x array definition uses the valueCol property to pass the initial variable values and the binding property to 'bind' to the vars_data data source. Since only one output property (finalValue:[]) is present within the x array definition, only the final variable values will be appended to the original cell address, Q2:R4. The last property, 'direction', indicates that the file will be both imported and exported hence the setting 'import/export'. Note:  If the 'initials' column heading in Excel is replaced with  'finalValue'. RASON will both read the initial variable values from cells R2:R4 and overwrite these values with the final variable values after the model is solved.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!Q2:R4",
+      "indexCols": [ "prods" ],
+      "valueCols": [ "initials" ],
+      "direction": "import/export"
+    },
+    "fcns_data": {
+      "comment": "The fcns_data datasource exports the final constraint values to the Excel file, ProductMixExcel.xlsx.  The first property, type: 'Excel', specifies the type of file where the data is being imported/exported, in this instance an Excel file. The second property, connection, specifies the file name within quotes ('ProductMixExce.xlsx'). The 3rd property, selection: 'Sheet1!U2:U6', gives the location, within the ProductMixExcel.xlsx workbook, where the final constraint values will be saved. Alternatively, we could pass a defined name here. The 4th property, indexCols, indexes the data by the 'prods' column (or dimension). The binding property within the c constraint definition binds the constraint block c to the fcns_data datasource. One output property (finalValue:[]) is included in the c definition. The RASON interpreter will append the final constraint values to the original selection. The last property, 'direction', indicates that the file will be exported. (The default setting for the direction property is 'import'.) For a complete list of results that may be written to a writeable data source, see the constraints section discussion within the RASON Reference Guide.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!U2:U6",
+      "indexCols": [ "parts" ],
+      "direction": "export"
+    },
+    "obj_data": {
+      "comment": "The obj_data datasource exports the final objective value to ProductMixExcel.xlsx.  The first property, type, specifies the file type ('Excel'), the second property, connection, specifies the file name ('ResultObj.txt') and the third property, selection, specifies where the final objective value will be written ('Sheet1!X1'). The binding property within the total objective definition the objective definition to the obj_data data source. Since only the finalValue result property is present within the objective definition, only the final value of the objective function (a single value) will be saved to ProductMixExcel!X2. The last property, 'direction', indicates that the file will be exported. For a complete list of results that may be written to a writeable data source, see the objective section discussion within the RASON Reference Guide.",
+      "type": "excel",
+      "connection": "ProductMixExcel.xlsx",
+      "selection": "Sheet1!X2",
+      "direction": "export"
+    }
+  },
+  "data": {
+    "comment": "Binds the datasources to data component.",
+    "parts2": {
+      "comment": "Binds the values in the qty column in the parts_data datasource to parts2 data component.",
+      "binding": "parts_data",
+      "valueCol": "qty"
+    },
+    "invent": {
+      "comment": "Binds the values in the inventory column in the invent_data datasource to invent data component.",
+      "binding": "invent_data",
+      "valueCol": "inventory"
+    },
+    "profit": {
+      "comment": "Binds the values in the profits column in the profit_data datasource to profit data component.",
+      "binding": "profit_data",
+      "valueCol": "profits"
+    }
+  },
+  "formulas": {
+    "comment": "Use this section to calculate intermediate formulas to be used within the constraints and objective sections.",
+    "piv_parts": {
+      "comment": "Calculates the amount of parts used to produce all three products.",
+      "formula": "PIVOT(parts2, { 'prods' }, { 'parts' })"
+    }
+  },
+  "variables": {
+    "comment": "Decision Variables",
+    "x": {
+      "comment": "The amount of products to produce, x[1] = TVs, x[2] = Stereos, x[3] = Speakers",
+      "dimensions": [ "prods" ],
+      "binding": "vars_data",
+      "valueCol": "initials",
+      "lower": 0,
+      "finalValue": [],
+      "indexValue": []
+    }
+  },
+  "constraints": {
+    "comment": "Constraints",
+    "c": {
+      "comment": "Generates 5 constraints that calculate the number of parts used in creating the three products, then sets each constraint equal to the amount of each part in inventory.",
+      "dimensions": [ "parts" ],
+      "binding": "fcns_data",
+      "formula": "MMULT(piv_parts, x) - invent",
+      "upper": 0,
+      "finalValue": []
+    }
+  },
+  "objective": {
+    "comment": "objective function",
+    "total": {
+      "comment": "Calculates the profit by multiplying the profit per unit of each product by the final variable values.",
+      "binding": "obj_data",
+      "formula": "sumproduct(x, profit)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/ReferenceGuide/RGProductMixSQL11.json

@@ -0,0 +1,108 @@
+{
+  "modelName": "RGProductMixSQL11",
+  "modelDescription": "RASON Conic Optimization Example that uses SQL table binding:  This example illustrates how to import and export data from an odbc database, specifically a Microsoft Access database. See the Named Data Connections within the RASON User Guide for more information on how to create a named data connection where you can maintain your data access credentials in a secure Azure 'vault' rather than passing them in the connection property.",
+  "modelType": "optimization",
+  "datasources": {
+    "comment": "Imports data from outside datasources. ValueCols must follow indexCols in selections",
+    "parts_data": {
+      "comment": "Imports the parts data.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "SELECT Parts as parts, Products as prods, Qty as qty FROM Parts ORDER BY ID",
+      "indexCols": [ "parts", "prods" ],
+      "valueCols": [ "qty" ],
+      "direction": "import"
+    },
+    "invent_data": {
+      "comment": "Imports the inventory data.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "SELECT Parts as parts, Inventory as inventory FROM Inventory ORDER BY ID",
+      "indexCols": [ "parts" ],
+      "valueCols": [ "inventory" ],
+      "direction": "import"
+    },
+    "profit_data": {
+      "comment": "Imports the profit per unit data.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "SELECT Products as prods, Profit as profit FROM Profits ORDER BY ID",
+      "indexCols": [ "prods" ],
+      "valueCols": [ "profit" ],
+      "direction": "import"
+    },
+    "vars_data": {
+      "comment": "The vars_data data source performs a dual function by first importing the decision variable initial values from the Access database and then saving the final variable values back to that same file. The first property, type, specifies the type of file where the data is being imported/exported ('msaccess'), the second property, connection, specifies the file name within quotes ('ProductMixAccess.accdb') and the third property, selection, imports two fields from the Profits table in order by ID ('SELECT Products, Initials FROM Profits ORDER BY ID). The 4th property, indexCols, indexes the data by the prods dimension while the 5th property, valueCols, imports the actual numerical data. The direction property ensures that the initial variable values are imported and the final variable values are exported using direction: 'import/export'. Within variables, the x array definition uses the valueCol property to pass the initial variable values and the binding property to bind to the vars_data data source. The final variable values (requested using the output property finalValues:[] within the x array definition) will be appended to the Profits table.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "SELECT Products as prods, Initials as initials FROM Profits ORDER BY ID",
+      "indexCols": [ "prods" ],
+      "valueCols": [ "initials" ],
+      "direction": "import/export"
+    },
+    "fcns_data": {
+      "comment": "The fcns_data datasource, exports the final constraint values to the Access data base file, ProductMixAccess.accdb. The first property, type: 'msaccess', specifies the type of file where the data is being imported/exported. Alternatively, 'access' or 'odbc' could have been passed instead of 'msaccess'. The second property, connection, specifies the file name within quotes ('ProductMixAcess.accdb'). The 3rd property, selection: 'ResultFcns', creates a table within the Access database, where the final constraint values will be saved. The direction property ensures that the file is 'exported'. Within the c constraint definition, the constraint block is bound to the fcns_data data source by the binding property. The output property, finalValue:[], will export the final constraint values to the ResultsFcns table within the file, ProductMixAccess.accdb.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "ResultFcns",
+      "direction": "export"
+    },
+    "obj_data": {
+      "comment": "The obj_data datasource exports the final objective value to ProductMixAccess.accdb. Again the first property, type, specifies the file type ('msaccess'), the second property, connection, specifies the file name ('ProductMixAccess.accdb') and the third property, selection, specifies the table where the final objective value will be written ('ResultObj').  The direction property ensures that the file is 'exported'. The binding property within the total objective definition 'binds' the objective to the obj_data source. The output property, finalValue:[], exports the final objective function value to the ResultObj table within the file ProductMixAccess.accdb.",
+      "type": "odbc",
+      "connection": "Driver={SQL Server};Server=tcp:solver.database.windows.net,1433;Database=Rason;Uid=rasonread;Pwd=Rason1234;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;",
+      "selection": "ResultObj",
+      "direction": "export"
+    }
+  },
+  "data": {
+    "comment": "Binds the datasources to data component.",
+    "profit": {
+      "comment": "Binds the values in the profits column in the profit_data datasource to profit data component. If valueCol property is missing, RASON assumes the value column is the last column in the table.",
+      "binding": "profit_data"
+    },
+    "invent": {
+      "comment": "Binds the values in the inventory column in the invent_data datasource to invent data component.",
+      "binding": "invent_data"
+    },
+    "parts2": {
+      "comment": "Binds the values in the qty column in the parts_data datasource to parts2 data component.",
+      "binding": "parts_data"
+    }
+  },
+  "formulas": {
+    "comment": "Use this section to calculate intermediate formulas to be used within the constraints and objective sections.",
+    "piv_parts": {
+      "formula": "PIVOT(parts2, { 'prods' }, { 'parts' })"
+    }
+  },
+  "variables": {
+    "comment": "Decision Variables",
+    "x": {
+      "comment": "The amount of products to produce, x[1] = TVs, x[2] = Stereos, x[3] = Speakers",
+      "dimensions": [ "prods" ],
+      "valuecol": "initials",
+      "lower": 0,
+      "finalValue": []
+    }
+  },
+  "constraints": {
+    "comment": "Constraints",
+    "c": {
+      "comment": "Generates 5 constraints that calculate the number of parts used in creating the three products, then sets each constraint equal to the amount of each part in inventory.",
+      "dimensions": [ "parts" ],
+      "formula": "MMULT(piv_parts, x)",
+      "upper": "invent",
+      "finalValue": []
+    }
+  },
+  "objective": {
+    "comment": "objective function",
+    "total": {
+      "comment": "Calculates the profit by multiplying the profit per unit of each product by the final variable values.",
+      "formula": "sumproduct(x, profit)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+{
+  "modelName": "UGAirlineHubCSV",
+  "modelDescription": "RASON Distance Minimization Nonlinear Optimization Example - This example is used in the Introduction chapter within the RASON User Guide (downloadable from the Help tab) to illustrate RASON's ability to import data from an outside source. Many realistic models use large tables of data, often drawn from multiple data fields or databases. The goal of this example is to find a location of an airline hub serving several regional airports. The location of the hub should be as close to equidistant to each airport served, as possible. In this example the datasources section imports a CSV file containing a list of coordinates for the regional airports. AirlineHubData.csv contains three columns:  'cities', containing the city name, dx and dy, containing the x and y coordinates of each airport. Our list of city coordinates is located in a CSV file, however, our data could also have been located in an ODBC database or an Excel file. Click Help - RASON Subscriptions -- Data Connections to see how to setup a secure data connection in RASON. To download AirlineHubData.csv, click Download RASON example data from the ribbon. To attach the file to the example, click Choose Files (on the Properties pane), browse to the location of the downloaded files, select AirlineHubData.csv and click Open. Then click POST (upload icon on ribbon) to post the model to the RASON Server.  Finally, click the down arrow next the Play icon and click Solve to solve the model. The x and y values in the final solution will be the x and y coordinates of the proprosed airline hub.",
+  "modelType": "optimization",
+  "engineSettings": {
+    "comment": "Since this model is nonlinear, the GRG Nonlinear engine is selected as the solving engine.",
+    "engine": "GRG Nonlinear"
+  },
+  "datasources": {
+    "comment": "The dataSources section defines a source from which the data values will be imported, in this case a comma-separated-value (CSV) file named AirlineHubData.csv.  The data source defines an index column, CITIES, which is used to dimension the array of constraints, c.",
+    "city_data": {
+      "type": "csv",
+      "connection": "AirlineHubData.csv",
+      "indexCols": [ "cities" ],
+      "valueCols": [ "dx", "dy" ],
+      "direction": "import"
+    }
+  },
+  "variables": {
+    "comment": "This example contains three decision variables x, y and z. The x and y variables will hold the final x and y coordinates of the proposed firehouse location. The third variable, z, will be minimized in the objective function. Since the finalValue property is present, the final value of each variable will be returned in the results.",
+    "x": {
+      "comment": "The x coordinate of the proposed airport location. Since the finalValue property is present, the final value of the objective function will be returned in the results.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "y": {
+      "comment": "The y coordinate of the proposed airport location. Since the finalValue property is present, the final value of the objective function will be returned in the results.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "z": {
+      "comment": "The z variable that will be minimized in the objective function. Since the finalValue property is present, the final value of the objective function will be returned in the results.",
+      "value": 1.0,
+      "finalValue": []
+    }
+  },
+  "data": {
+    "comment": "In the data section of the model, we bind the names dx and dy to 1-dimensional arrays from the corresponding value columns dx and dy. This model can be used to solve many different instances of this facility location problem, for a variable number of cities.",
+    "dx": {
+      "comment": "x coordinates of each city bound to the dx data array.",
+      "binding": "city_data",
+      "valueCol": "dx"
+    },
+    "dy": {
+      "comment": "y coordinates of each city bound to the dy data array.",
+      "binding": "city_data",
+      "valueCol": "dy"
+    }
+  },
+  "constraints": {
+    "c": {
+      "comment": "There will be 1 constraint per city regional airport. The distance formula is used to calculate the distance bewteen the proprosed hub's location and the city regional airport.",
+      "dimensions": [ "cities", 1 ],
+      "upper": 0,
+      "formula": "sqrt((x - dx)^2 + (y - dy)^2) - z"
+    }
+  },
+  "objective": {
+    "comment": "The objective function minimizes the z variable creating a squashing effect that pushes the distances between the proposed airling hub and the distance between each city airport to be as small as possible.",
+    "obj": {
+      "comment": "Since the finalValue property is present, the final value of the objective function will be returned in the results. Note that the final value for the z variable and the objective will be equal.",
+      "type": "minimize",
+      "formula": "z",
+      "finalValue": []
+    }
+  }
+}

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

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

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

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

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

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

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

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

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

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