@frontlinesystems/rason-mcp-server 2026.5.0

package/examples/rason-features/BoxLambdaExamples/BoxFunSimulate.json

@@ -0,0 +1,119 @@
+{
+  "modelName": "BoxFunctionSimulation",
+  "modelType": "simulation",
+  "modelDescription": "Simulation model containing a box function that calculates the predicted daily price of a stock. In the original example, GBM Simulation Example, the daily predicted stock price is calculated using a typical formula entered into the 'formulas' section.  In this example, the predicted daily stock price is calculated using a custom, reusable Box Function.  Box Functions are an easy, reliable method to replicate formulas in a RASON model. For more information on Box Functions, see Defining Custom Functions on the Help tab. ",
+  "boxFunctions": {
+    "comment": "Use a box function to create a custom, reusable function which can be called to calculate intermediary formulas, constraints or the objective.  Box functions are a reliable way to calculate a formula that is called many times in a model. There is one box function in this model, funDailyPrice.",
+    "funDailyPrice": {
+      "comment": "The name of the box function is 'funDailyPrice'. The 'inputs' property (required) lists the input parameter to the function. The 'inputTypes' property (optional) gives the type of each input.  In this example, both input parameters must be numbers. The property 'language' (required) can only be 'Excel' or 'FEEL'. This property determines what syntax is used in the box function. The property 'resultType' specifies the type of the result.  In this case, the function will return a number. The body of the function is where the intermediary formula calculations are performed. The names, 'formula1', 'formula2' and 'formula3' are the users choice. The property 'result' (required) calculates the result of the function.  The result can accept formulas calculated within the 'body' of the function.",
+      "inputs": [ "PrevClose", "NormDist" ],
+      "inputTypes": [ "number", "number" ],
+      "language": "EXCEL",
+      "resultType": "number",
+      "body": {
+        "formula1": {
+          "formula": "Volatility*SQRT(1/NumDays)*NormDist"
+        },
+        "formula2": {
+          "formula": "EXP((AppRate-Volatility^2*0.5)*(1/NumDays))"
+        },
+        "formula3": {
+          "formula": "PrevClose"
+        }
+      },
+      "result": "PrevClose*(Formula2 + formula1)"
+    }
+  },
+  "uncertainVariables": {
+    "comment": "These are the uncertain variables in the model. There are 5 total uncertain functions.",
+    "NormDist1": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist2": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist3": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist4": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist5": {
+      "formula": "PsiNormal(0,1)"
+    }
+  },
+  "data": {
+    "comment": "Use the 'data' section to organize constant parameters in the model:  volatility parameter, number of days (NumDays), appreciation rate (AppRate) and the first closing price(FirstClose).",
+    "Volatility": {
+      "value": 0.09486,
+      "binding": "get",
+      "comment": "vol"
+    },
+    "NumDays": {
+      "value": 100,
+      "binding": "get",
+      "comment": "numdays"
+    },
+    "AppRate": {
+      "value": 0.0234992098,
+      "binding": "get",
+      "comment": "apprate"
+    },
+    "FirstClose": {
+      "value": 20.33,
+      "binding": "get",
+      "comment": "firstclose"
+    }
+  },
+  "formulas": {
+    "comment": "Use the 'formulas' section to calculate intermediary formulas. The results of which can be used to calculate constraints and the objective. Each of the DailyPrice formula calls the funDailyPrice box function to calculate the predicted daily stock price. ",
+    "DailyPrice1": {
+      "formula": "funDailyPrice(FirstClose,NormDist1)"
+    },
+    "DailyPrice2": {
+      "formula": "funDailyPrice(DailyPrice1,NormDist2)"
+    },
+    "DailyPrice3": {
+      "formula": "funDailyPrice(DailyPrice2,NormDist3)"
+    },
+    "DailyPrice4": {
+      "formula": "funDailyPrice(DailyPrice3,NormDist4)"
+    },
+    "DailyPrice5": {
+      "formula": "funDailyPrice(DailyPrice4,NormDist5)"
+    }
+  },
+  "uncertainFunctions": {
+    "comment": "All uncertain functions must be entered into the 'uncertainFunctions' section. ",
+    "ExpDailyPrice1": {
+      "comment": "This uncertain function calls the funDailyPrice box function to calculate the 1st day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "funDailyPrice(FirstClose,NormDist1)",
+      "trials": [],
+      "mean": []
+    },
+    "ExpDailyPrice2": {
+      "comment": "This uncertain function calls the funDailyPrice box function to calculate the 2nd day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "DailyPrice2",
+      "trials": [],
+      "mean": []
+    },
+    "ExpDailyPrice3": {
+      "comment": "This uncertain function calls the funDailyPrice box function to calculate the 3rd day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "DailyPrice3",
+      "trials": [],
+      "mean": []
+    },
+    "ExpDailyPrice4": {
+      "comment": "This uncertain function calls the funDailyPrice box function to calculate the 4th day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "DailyPrice4",
+      "trials": [],
+      "mean": []
+    },
+    "ExpDailyPrice5": {
+      "comment": "This uncertain function calls the funDailyPrice box function to calculate the 5th day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "DailyPrice5",
+      "trials": [],
+      "mean": []
+    }
+  }
+}

package/examples/rason-features/BoxLambdaExamples/LambdaFunOptimize.json

@@ -0,0 +1,143 @@
+{
+  "modelName": "LambdaFunOptimize",
+  "modelDescription": "In this example, a LAMBDA Excel functon is used to create a custom, reusable function that can be called mulitiple times to calculate the distance between a proposed airline hub and 6 regional airports.  Notice that the decision varaibles, constraints and the objective function have not changed from the original AirlineHub example under Examples - Optimization - Nonlinear.",
+  "modelType": "optimization",
+  "engineSettings": {
+    "comment": "Select the GRG nonlinear engine to solve the nonlinear model. Setting 'scaling' to -1 turns off scaling.",
+    "engine": "GRG Nonlinear",
+    "scaling": -1
+  },
+  "boxFunctions": {
+    "comment": "Use the 'boxFunctions' section to add either a box function or a lambda function to the RASON model. A LAMBDA function can be used to create custom, reusable functions which can be invoked in a RASON model, much like a box function.",
+    "DistanceFormula": {
+      "comment": "This custom LAMBDA function calculates the distance between two points. In this example, this function will be called to calculate the distance between the proposed hub and each of th 6 regional airports.",
+      "result": "LAMBDA(xone,xtwo,yone,ytwo,SQRT((xtwo-xone)^2+(ytwo-yone)^2))"
+    }
+  },
+  "variables": {
+    "comment": "The 'variables' section holds all the decision variables in the optimization model. There are three.",
+    "e13:f13": {
+      "comment": "The first two variables represent the x,y coordinates of the proposed airline hub.",
+      "value": 1,
+      "finalValue": []
+    },
+    "g20": {
+      "comment": "The third variable is an artificial variable that, when minimized in the objective, will have a squashing effect on the distance formula. In the final solution, this variable's value will equal the maximum constraint value.",
+      "value": 1,
+      "finalValue": []
+    }
+  },
+  "data": {
+    "comment": "Use the 'data' section to organize constant data parameters.",
+    "e14": {
+      "comment": "The x coordinate of the 1st regional airport.",
+      "value": 6
+    },
+    "f14": {
+      "comment": "The x coordinate of the 1st regional airport.",
+      "value": 2
+    },
+    "e15": {
+      "comment": "The x coordinate of the 2nd regional airport.",
+      "value": 5
+    },
+    "f15": {
+      "comment": "The y coordinate of the 2nd regional airport.",
+      "value": 5
+    },
+    "e16": {
+      "comment": "The x coordinate of the 3rd regional airport.",
+      "value": 4
+    },
+    "f16": {
+      "comment": "The y coordinate of the 3rd regional airport.",
+      "value": 8
+    },
+    "e17": {
+      "comment": "The x coordinate of the 4th regional airport.",
+      "value": 3
+    },
+    "f17": {
+      "comment": "The y coordinate of the 4th regional airport.",
+      "value": 4
+    },
+    "e18": {
+      "comment": "The x coordinate of the 5th regional airport.",
+      "value": 3
+    },
+    "f18": {
+      "comment": "The y coordinate of the 5th regional airport.",
+      "value": 3
+    },
+    "e19": {
+      "comment": "The x coordinate of the 6th regional airport.",
+      "value": 1
+    },
+    "f19": {
+      "comment": "The y coordinate of the 6th regional airport.",
+      "value": 2
+    }
+  },
+  "formulas": {
+    "comment": "Use the 'formulas' section to calcualte intermediary formulas which can then be used to calculate constraints or the objective.",
+    "g14": {
+      "comment": "The first constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 1st regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 1st regional airport in cells D14 and F14.",
+      "formula": "DistanceFormula($E$13,E14,$F$13,F14)"
+    },
+    "g15": {
+      "comment": "The second constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 2nd regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 2nd regional airport in cells D15 and F15.",
+      "formula": "DistanceFormula($E$13,E15,$F$13,F15)"
+    },
+    "g16": {
+      "comment": "The third constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 3rd regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 3rd regional airport in cells D16 and F16.",
+      "formula": "DistanceFormula($E$13,E16,$F$13,F16)"
+    },
+    "g17": {
+      "comment": "The fourth constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 4th regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 4th regional airport in cells D17 and F17.",
+      "formula": "DistanceFormula($E$13,E17,$F$13,F17)"
+    },
+    "g18": {
+      "comment": "The fifth constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 5th regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 5th regional airport in cells D18 and F18.",
+      "formula": "DistanceFormula($E$13,E18,$F$13,F18)"
+    },
+    "g19": {
+      "comment": "The sixth constraint calls the Lambda function, DistanceFormula, to calculate the distance between the proposed hub location and the 6th regional airport by passing the x and y coordiantes of the proposed hub (the decision variable values), E13 and F13, and the x and y coordinates of the 6th regional airport in cells D19 and F19.",
+      "formula": "DistanceFormula($E$13,E19,$F$13,F19)"
+    }
+  },
+  "constraints": {
+    "comment": "Sets the artificial variable, G20, to constraint the distance calculation for each regional airport. In the final solution, cell G20 will be equal to the maximum constraint value or MAX(G14, G15, G16, G17, G18, G19). ",
+    "airport1con": {
+      "formula": "g14 - g20",
+      "upper": 0
+    },
+    "airport2con": {
+      "formula": "g15 - g20",
+      "upper": 0
+    },
+    "airport3con": {
+      "formula": "g16 - g20",
+      "upper": 0
+    },
+    "airport4con": {
+      "formula": "g17 - g20",
+      "upper": 0
+    },
+    "airport5con": {
+      "formula": "g18 - g20",
+      "upper": 0
+    },
+    "airport6con": {
+      "formula": "g19 - g20",
+      "upper": 0
+    }
+  },
+  "objective": {
+    "comment": "Minimizes the artifical variable, G20.  This creates a squashing effect on the distance calculations.  In the final solution, cell G20 will be equal to the maximum constraint value or MAX(G14, G15, G16, G17, G18, G19). ",
+    "objective": {
+      "formula": "g20",
+      "type": "min",
+      "finalValue": []
+    }
+  }
+}

package/examples/rason-features/BoxLambdaExamples/LambdaFunSimulate.json

@@ -0,0 +1,82 @@
+{
+  "comment": "Simulation Model with Lambda Function",
+  "modelName": "LambdaFunSimulate",
+  "modelDescription": "In this example, a LAMBDA Excel functon is used to create a custom, reusable function that can be called mulitiple times to calculate the predicted daily stock price.  Notice that the decision varaibles, constraints and the objective function have not changed from the original GBM Simulation Model under Examples - Simulation.",
+  "modelType": "simulation",
+  "boxFunctions": {
+    "comment": "Use the 'boxFunctions' section to add either a box function or a lambda function to the RASON model. A LAMBDA function can be used to create custom, reusable functions which can be invoked in a RASON model, much like a box function.",
+    "PredDailyPrice": {
+      "comment": "In this example, the lambda function will be called to calculate the daily predicted stock price.",
+      "result": "LAMBDA(Volatility,NumofDays,NormDist,Appreciation,Previous,Previous*(Volatility*SQRT(1/NumofDays)*NormDist+ EXP((Appreciation-Volatility^2*0.5)*(1/NumofDays))))"
+    }
+  },
+  "uncertainVariables": {
+    "comment": "These are the uncertain variables in the model. There are 5 total uncertain functions.",
+    "NormDist1": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist2": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist3": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist4": {
+      "formula": "PsiNormal(0,1)"
+    },
+    "NormDist5": {
+      "formula": "PsiNormal(0,1)"
+    }
+  },
+  "data": {
+    "comment": "Use the 'data' section to organize constant parameters in the model:  volatility parameter, number of days (NumDays), appreciation rate (AppRate) and the first closing price(FirstClose).",
+    "FirstClose": {
+      "value": 20.33
+    },
+    "Volatility": {
+      "value": 0.09486,
+      "comment": "volatility"
+    },
+    "NumofDays": {
+      "value": 100,
+      "comment": "numofdays"
+    },
+    "Appreciation": {
+      "value": 0.0234992098,
+      "comment": "appreciation"
+    }
+  },
+  "uncertainFunctions": {
+    "comment": "All uncertain functions must be entered into the 'uncertainFunctions' section. ",
+    "DayOne": {
+      "comment": "This uncertain function calls the predDailyPrice lambda function to calculate the 1st day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "PredDailyPrice(Volatility,NumofDays,NormDist1,Appreciation,FirstClose)",
+      "mean": [],
+      "trials": []
+    },
+    "DayTwo": {
+      "comment": "This uncertain function calls the predDailyPrice lambda function to calculate the 2nd day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "PredDailyPrice(Volatility,NumofDays,NormDist2,Appreciation,DayOne)",
+      "mean": [],
+      "trials": []
+    },
+    "DayThree": {
+      "comment": "This uncertain function calls the predDailyPrice lambda function to calculate the 3rd day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "PredDailyPrice(Volatility,NumofDays,NormDist3,Appreciation,DayTwo)",
+      "mean": [],
+      "trials": []
+    },
+    "DayFour": {
+      "comment": "This uncertain function calls the predDailyPrice lambda function to calculate the 4th day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "PredDailyPrice(Volatility,NumofDays,NormDist4,Appreciation,DayThree)",
+      "mean": [],
+      "trials": []
+    },
+    "DayFive": {
+      "comment": "This uncertain function calls the predDailyPrice lambda function to calculate the 5th day's predicted daily stock price. All 1000 trial values and the mean of the function will be returned in the result.",
+      "formula": "PredDailyPrice(Volatility,NumofDays,NormDist5,Appreciation,DayFour)",
+      "mean": [],
+      "trials": []
+    }
+  }
+}

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

@@ -0,0 +1,69 @@
+{
+  "modelName": "RGFirehouseLocation",
+  "modelDescription": "RASON Conic Optimization Example: Example of solving a nonlinear Optimization Model with Cone Constraints. The goal of this example is to find a location, given by x and y coordinates, of a proposed firehouse that minimizes the maximum distance between the firehouse and six cities in the region.",
+  "modelType": "optimization",
+  "engineSettings": {
+    "comment": "Since this model is nonlinear, the GRG Nonlinear engine is selected as the solving engine.",
+    "engine": "GRG Nonlinear"
+  },
+  "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 firehouse location.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "y": {
+      "comment": "The y coordinate of the proposed firehouse location.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "z": {
+      "comment": "The z variable that will be minimized in the objective function.",
+      "value": 1.0,
+      "finalValue": []
+    }
+  },
+  "constraints": {
+    "comment": "The constraints calculate the distance between the proposed firehouse location and each of the six cities using the the Pythagorean Theorem (SQRT ((Xc – X )^2 + (Yc – Y) ^2)), which is a nonlinear function of the variables.",
+    "c1": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 1.",
+      "formula": "sqrt((x - 1)^2 + (y - 4)^2) - z",
+      "upper": 0
+    },
+    "c2": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 2.",
+      "formula": "sqrt((x - 0.5)^2 + (y - 3)^2) - z",
+      "upper": 0
+    },
+    "c3": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 3.",
+      "formula": "sqrt((x - 2)^2 + (y - 4)^2) - z",
+      "upper": 0
+    },
+    "c4": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 4.",
+      "formula": "sqrt((x - 2)^2 + (y - 2)^2) - z",
+      "upper": 0
+    },
+    "c5": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 5.",
+      "formula": "sqrt((x - 2)^2 + (y - 5)^2) - z",
+      "upper": 0
+    },
+    "c6": {
+      "comment": "Calculates the distance between the proposed firehouse location and city 6.",
+      "formula": "sqrt((x - 0.5)^2 + (y - 6)^2) - z",
+      "upper": 0
+    }
+  },
+  "objective": {
+    "comment": "The objective function minimizes the z variable creating a squashing effect that pushes the distances between the proposed firehouse location and the distance between each city 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 objective function and the z variable will be equal.",
+      "formula": "z",
+      "type": "minimize",
+      "finalValue": []
+    }
+  }
+}

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

@@ -0,0 +1,114 @@
+{
+  "modelName": "RGFirehouseLocationConic",
+  "modelDescription": "RASON Conic Optimization Example: Example of solving a Conic Optimization Model. The goal of this example is the same for the RGFirehouseLocation example, to find a location, given by x and y coordinates, of a proposed firehouse that minimizes the maximum distance between the firehouse and six cities in the region. The difference between this example and the RGFirehouseLocation example is that this example replaces the 6 nonlinear constraints (calculating the distances betwen the proposed firehouse location and each city) with a 6 conic constraints. Since the model is now a conic optimization model, the SOCP Barrier engine can be used. ",
+  "modelType": "optimization",
+  "engineSettings": {
+    "comment": "Since the model is now a conic optimization model, the SOCP Barrier engine can be used to solve the model. Note:  In RASON, you can solve any type of model containing conic constraints. There is no need to select a specific engine within engineSettings. If the model is diagnosed as 'SOCP', then the model will be solved using an engine that supports conic constraints. Currently, the three engines that support conic constraints are: 'SOCP Barrier', 'Gurobi Solver' and 'Mosek Solver'.",
+    "engine": "SOCP Barrier"
+  },
+  "variables": {
+    "comment": "The variables for this conic formulation contains the three original variables: x and y, which will hold the final x,y coordinate values for the proposed firehouse and z, the variale to be minimized in the objective function. 18 new variables in the f, g and h arrays, are required for the 6 conic constraints. Each member of the f, g, and h variable blocks must (for example f[1], g[1], and h[1]) belong to a second order cone constraint  which can be rewritten as f[1] > = SQRT (SUMSQ(g[1]; h[1])).  ",
+    "x": {
+      "comment": "The x variable will hold the final x coordinate of the proposed firehouse.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "y": {
+      "comment": "The y variable will hold the final y coordinate of the proposed firehouse.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "z": {
+      "comment": "The z variable will be minimized in the objective.",
+      "value": 1.0,
+      "finalValue": []
+    },
+    "f": {
+      "comment": "The f block of variables will be forced by the dx block of constraints to equal the distance between the x coordinate of the proposed firehouse and the x coordinate of each city.",
+      "dimensions": [ 6 ],
+      "value": 1.0,
+      "finalValue": []
+    },
+    "g": {
+      "comment": "The g block of variables will be forced by the dy block of constraints to equal the distance between the y coordinate of the proposed firehouse and the y coordinate of each city.",
+      "dimensions": [ 6 ],
+      "value": 1.0
+    },
+    "h": {
+      "comment": "The h block of variables will be driven by the dz block of constraints to be less than or equal to z, the variable to be minimized in the objective function.",
+      "dimensions": [ 6 ],
+      "value": 1.0
+    }
+  },
+  "data": {
+    "comment": "The x and y coordinates of each of the 6 cities to be served by the firehouse are given in the corx and cory arrays, respectively. In the RGFirehouseLocation example, these coordinates were supplied in the constraint formulas.",
+    "corx": {
+      "comment": "x coordinates of the each of the 6 cities.",
+      "dimensions": [ 6 ],
+      "value": [ 1, 0.5, 2, 2, 2, 0.5 ]
+    },
+    "cory": {
+      "comment": "y coordinates of the each of the 6 cities.",
+      "dimensions": [ 6 ],
+      "value": [ 4, 3, 4, 2, 5, 6 ]
+    }
+  },
+  "constraints": {
+    "dx": {
+      "comment": "This constraint calculates the differences between the X coordinates of the hub and each city set equal to the new variables in the g block.",
+      "dimensions": [ 6 ],
+      "formula": "corx - x - g",
+      "equal": 0
+    },
+    "dy": {
+      "comment": "This constraint calculates the differences between the Y coordinates of the hub and each city set equal to the new variables in the h block.",
+      "dimensions": [ 6 ],
+      "formula": "cory - y - h",
+      "equal": 0
+    },
+    "dz": {
+      "comment": "The effect of this constraint, coupled with the minimization of the Z variable, results in the Z variable being set equal to the maximum value in the F variable block, in the final solution.",
+      "dimensions": [ 6 ],
+      "formula": "f - z",
+      "upper": 0
+    },
+    "cone1": {
+      "comment": "Each set of the f, g, and h variables must belong to a second order cone constraint which can be rewritten as F >= SQRT(SUMSQ(G,H)), in this constraint specifically: F[1] >= SQRT(SUMSQ(G[1],H[1])). These 6 conic constraints replace the nonlinear distance calculation in the previous RGFirehouseLocation example.",
+      "value": "f[1], g[1], h[1]",
+      "type": "cone"
+    },
+    "cone2": {
+      "comment": "F[2] >= SQRT(SUMSQ(G[2],H[2]))",
+      "value": "f[2], g[2], h[2]",
+      "type": "cone"
+    },
+    "cone3": {
+      "comment": "F[3] >= SQRT(SUMSQ(G[3],H[3]))",
+      "value": "f[3], g[3], h[3]",
+      "type": "cone"
+    },
+    "cone4": {
+      "comment": "F[4] >= SQRT(SUMSQ(G[4],H[4]))",
+      "value": "f[4], g[4], h[4]",
+      "type": "cone"
+    },
+    "cone5": {
+      "comment": "F[5] >= SQRT(SUMSQ(G[5],H[5]))",
+      "value": "f[5], g[5], h[5]",
+      "type": "cone"
+    },
+    "cone6": {
+      "comment": "F[6] >= SQRT(SUMSQ(G[6],H[6]))",
+      "value": "f[6], g[6], h[6]",
+      "type": "cone"
+    }
+  },
+  "objective": {
+    "obj": {
+      "comment": "Minimizing the z variable in the objective function will push the maximum distance between the proposed firehouse location and each city to the lowest possible value guaranteeing that the firehouse is as close as possible to each of the six cities. ",
+      "formula": "z",
+      "type": "minimize",
+      "finalValue": []
+    }
+  }
+}

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

@@ -0,0 +1,108 @@
+{
+  "modelName": "RGProductMixCsv1",
+  "modelDescription": "RASON Conic Optimization Example: Illustrates binding to a CSV File. In this example, initial variable values are first imported from the CSV file ResultVarsInit.txt and, after the model is solved, the final variable values are saved back to that same CSV file. The final constraint values are saved to ResultFcns.txt and the final objective value is saved to ResultObj.txt. Both ResultFcns.txt and ResultObj.txt will be created once the model is solved. (Click Download RASON Examples icon to download all source files. To attach the files to the example, click Choose Files, navigate to the location of the saved files, select ProductMixParts.txt, ProductMixInventory.txt, ProductMixProfits.txt and ResultVarsInit.txt and click Open. Then POST the model by clicking the POST icon, then solve the model by clicking the down arrow next to the Play icon and selecting Solve.",
+  "modelType": "optimization",
+  "datasources": {
+    "comment": "Imports data from outside datasources.",
+    "parts_data": {
+      "comment": "Imports the parts data.",
+      "type": "csv",
+      "connection": "ProductMixParts.txt",
+      "indexCols": [ "parts", "prods" ],
+      "valueCols": [ "qty" ],
+      "direction": "import"
+    },
+    "invent_data": {
+      "comment": "Imports the inventory data.",
+      "type": "csv",
+      "connection": "ProductMixInventory.txt",
+      "indexCols": [ "parts" ],
+      "valueCols": [ "inventory" ],
+      "direction": "import"
+    },
+    "profit_data": {
+      "comment": "Imports the profit per unit data.",
+      "type": "csv",
+      "connection": "ProductMixProfits.txt",
+      "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 CSV file ResultVarsInit.txt 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 ('csv') while the second property, connection, specifies the file name within quotes ('ResultVarsInit.txt'). The third and fourth properties (indexCols and valueCols) are required for importing the initial variable values. The third property, indexCols specifies the dimension(s) (or column(s)) to be imported and the fourth property, valueCols, specifies the values to be imported.  Within variables, a block of decision variables x is bound to the vars_data data source using the binding property.  Since  only one output property is passed within the x definition, finalValue:[], a single column containing the final values of the decision variables will be appended to ResultVarsInit.txt. The last property, direction: 'import/export', stipulates that the contents of the file will be 'imported' (for initial variable values) and then the final variable values will be 'exported', hence the setting 'import/export'.",
+      "type": "csv",
+      "connection": "ResultVarsInit.txt",
+      "indexCols": [ "prods" ],
+      "valueCols": [ "initials" ],
+      "direction": "import/export"
+    },
+    "fcns_data": {
+      "comment": "The fcns_data datasource exports the final constraint values to the TXT file, ResultFcns.txt. The first property, type, specifies the type of file where the data is being imported/exported. In this example, the file is a CSV file.   The second property, connection, specifies the file name within quotes ('ResultFcns.txt') while the third property assigns the direction of the file as 'export'. The binding property within the c constraint definition binds the constraint block to the fcns_data data source. The user must specify which results he/she would like exported. In this example, only one output property is passed, finalValue:[].  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 on the Help tab.",
+      "type": "csv",
+      "connection": "ResultFcns.txt",
+      "direction": "export"
+    },
+    "obj_data": {
+      "comment": "The obj_data datasource exports the final objective value to the TXT file, ResultObj.txt. The first property, type, specifies the file type ('CSV') while the second property, connection, specifies the file name ('ResultObj.txt')and the third, direction, specifies that the file will be exported. Within objective, the total objective function is bound to the obj_data data source.  The only output property passed within the objective definition is finalValue:[].  As a result, only the final objective function value will be exported to ResultObj.txt.   For a complete list of results that may be written to a writeable data source, see the objective section discussion in the RASON Reference Guide.",
+      "type": "csv",
+      "connection": "ResultObj.txt",
+      "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",
+      "binding": "vars_data",
+      "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" ],
+      "binding": "fcns_data",
+      "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.",
+      "binding": "obj_data",
+      "formula": "sumproduct(x, profit)",
+      "type": "maximize",
+      "finalValue": []
+    }
+  }
+}