@frontlinesystems/rason-mcp-server 2026.5.0

package/examples/calculation/DMNExamples/FEEL Some or Every example.json

@@ -0,0 +1,66 @@
+{
+  "modelName": "FEEL_Some_or_Every_example",
+  "comment": "Example of 'Some/Every' iteration in FEEL",
+  "modelType": "calculation",
+  "typeDefs": {
+    "tLoan": {
+      "components": {
+        "principal": {
+          "type": "number",
+          "allowedValues": [ ">0" ]
+        },
+        "rate": {
+          "type": "number",
+          "allowedValues": [ "[0..1]" ]
+        },
+        "termMonths": {
+          "type": "number",
+          "allowedValues": [ ">0" ]
+        }
+      },
+      "language": "Feel"
+    },
+    "tLoanList": {
+      "language": "Feel",
+      "typeRef": "tLoan",
+      "isCollection": true
+    }
+  },
+  "boxFunctions": {
+    "funPMT": {
+      "inputs": [ "loan" ],
+      "inputTypes": [ "tLoan" ],
+      "language": "Feel",
+      "resultType": "number",
+      "body": {
+        "payment": {
+          "formula": "(loan.principal*loan.rate/12) / (1 - (1 + loan.rate/12)**-loan.termMonths)"
+        },
+        "fee": {
+          "formula": "0.01 * payment"
+        }
+      },
+      "result": "payment + fee"
+    }
+  },
+  "data": {
+    "loans": {
+      "type": "tLoanList",
+      "value": [
+        [ 600000, 0.0375, 360 ],
+        [ 100000, 0.0375, 360 ]
+      ],
+      "binding": "get"
+    }
+  },
+  "formulas": {
+    "MonthlyPayment": {
+      "feelFormula": "for i in loans return funPMT(i)",
+      "finalValue": []
+    },
+    "LoanAcceptable": {
+      "feelFormula": "if (every i in MonthlyPayment satisfies i < 2000) then 'accept' else 'reject'",
+      "finalValue": []
+    }
+  }
+}

package/examples/calculation/DecisionTables/DT Datasource example.json

@@ -0,0 +1,53 @@
+{
+  "modelName": "DTDatasourceExample",
+  "comment": "Decision table inputs from a datasource: This RASON decision table example illustrates how to provide an outside data source. Decision Tables contain a set of rules which specify actions to perform based on specific conditions.  Decision tables are a good tool to use when there is a consistent number of rules, or conditions, to be evaluated followed by a specific set of actions to be performed once a rule, or condition, is met. In this example, the customer data is supplied in the DT Customers.txt CSV file. The decisiont table in this example generates a medical rating for a patient based on the age of the patient and his/her medical history.",
+  "modelType": "calculation",
+  "datasources": {
+    "comment": "Specify outside data sources within the 'datasources' section of a RASON model.",
+    "cust_data": {
+      "comment": "The CSV file, DT Customers.txt contains the input parameters for the decision table, PolicyUnique.",
+      "type": "csv",
+      "connection": "DT Customers.txt",
+      "selection": "",
+      "indexCols": [ "custID" ],
+      "valueCols": [ "custAge", "medHistory" ],
+      "direction": "import"
+    }
+  },
+  "data": {
+    "comment": "The input parameters, custAge and medHistory, are bound to the age and med variables within the data section.",
+    "age": {
+      "comment": "The input parameter custAge from the DT Customers.txt CSV file is bound to the age variable.",
+      "binding": "cust_data",
+      "valueCol": "custAge"
+    },
+    "med": {
+      "comment": "The input parameter medHistory from the DT Customers.txt CSV file is bound to the med variable.",
+      "binding": "cust_data",
+      "valueCol": "medHistory"
+    }
+  },
+  "decisionTables": {
+    "comment": "Decision tables are created within the decisionTable section in a RASON model. In this example, there is 1 decision table, the PolicyUnique decision table.",
+    "PolicyUnique": {
+      "comment": "In this decision table, the input and output parameters are passed using the 'inputs' and 'outputs' properties, respectively.  It's possible to provide types for the inputs and outputs, see the DTDateTimeExample. The decision table rules appear under 'rules'.  The hit policy must be specified using 'hitPolicy'.",
+      "inputs": [ "age", "medHistory" ],
+      "outputs": [ "riskRating", "rule" ],
+      "rules": [
+        [ ">60,<25", "good", "medium", "r1" ],
+        [ ">60", "bad", "high", "r2" ],
+        [ "[25..60]", "-", "medium", "r3" ],
+        [ "<25", "good", "low", "r4" ],
+        [ "<25", "bad", "medium", "r5" ]
+      ],
+      "hitPolicy": "U"
+    }
+  },
+  "formulas": {
+    "comment": "The decision table is called and calculated within the formulas section. The res function calls the PolicyUnique decision table with two inputs, age, and med.  Both input parameters are supplied through the DT Customers.txt CSV file. The result of the decision table will be returned in the result. ",
+    "res": {
+      "formula": "PolicyUnique(,,age[1], med[1])",
+      "finalValue": []
+    }
+  }
+}

package/examples/calculation/DecisionTables/DT Date and Time examples.json

@@ -0,0 +1,92 @@
+{
+  "modelName": "DTDateTimeExample",
+  "modelType": "calculation",
+  "modelDescription": "RASON Date and Time Decision Table Examples: Decision Tables contain a set of rules which specify actions to perform based on specific conditions.  Decision tables are a good tool to use when there is a consistent number of rules, or conditions, to be evaluated followed by a specific set of actions to be perfrmed once a rule, or condition, is met. This example contains 3 decision tables, tblRiskRating, tblTollTax and tblParkingFee.",
+  "decisionTables": {
+    "comment": "Decision tables are created within the decisionTable section in a RASON model. In this example, there are 3 decision tables, tblRiskRating, tblTollTax and tblParkingFee",
+    "tblRiskRating": {
+      "comment": "This decision table generates a predicted medical rating based on the age of a patient and his/her's medical history.  This decision table accepts two inputs, birthDate of type date, and medHistory of type text, and returns a RiskRating of type text. The hit policy for this table is 'U' for unique.  Unique (U):  A unique rule must 'hit' evaluating to a unique result.  If multiple rules are valid, an error will be returned.",
+      "inputs": [ "birthDate", "medHistory" ],
+      "outputs": [ "riskRating" ],
+      "inputTypes": [ "date", "text" ],
+      "outputTypes": [ "text" ],
+      "rules": [
+        [ ">'1970-05-05'", "good", "medium" ],
+        [ ">'1970-05-05'", "bad", "high" ],
+        [ "['1935-05-05'..'1970-05-05']", "-", "medium" ],
+        [ "<'1935-05-05'", "good", "low" ],
+        [ "<'1935-05-05'", "bad", "medium" ]
+      ],
+      "hitPolicy": "U"
+    },
+    "tblTollTax": {
+      "comment": "This decision table generates a toll amount based the time a car enters the toll road.  This decision table accepts one input, operTime of type time, and returns two outputs: traffic of type text and toll of type number. The hit policy for this table is 'U' for unique.",
+      "inputs": [ "operTime" ],
+      "outputs": [ "traffic", "toll" ],
+      "refTypes": [ "time", "text", "number" ],
+      "rules": [
+        [ ">'19:00:00'", "low", 5 ],
+        [ "['15:00:00'..'19:00:00']", "high", 7 ],
+        [ "['09:00:00'..'15:00:00')", "medium", 6 ],
+        [ "['06:00:00'..'09:00:00')", "high", 7 ],
+        [ "<'06:00:00'", "low", 5 ]
+      ],
+      "hitPolicy": "U"
+    },
+    "tblParkingFee": {
+      "comment": "This decision table generates a parking fee based on the time a car spends in a parking garage. This decision table accepts one input, dtDuration of type duration, and returns one outputs, parkingFee of type number. The hit policy for this table is 'U' for unique.",
+      "inputs": [ "dtDuration" ],
+      "outputs": [ "parkingFee" ],
+      "refTypes": [ "duration", "number" ],
+      "rules": [
+        [ "<'PT20M'", 0 ],
+        [ "['PT20M'..'PT1H')", "2 *ceiling(duration(dtDuration)/duration('PT20M'))" ],
+        [ "['PT1H'..'PT4H')", "6 *ceiling(duration(dtDuration)/duration('PT1H'))" ],
+        [ ">='PT4H'", "30*ceiling(duration(dtDuration)/duration('P1D'))" ]
+      ],
+      "hitPolicy": "U"
+    }
+  },
+  "data": {
+    "comment": "The data section holds the input parameters for each decision table.",
+    "Date1": {
+      "comment": "This is a patient's date of birth.",
+      "value": "'1964-05-05'"
+    },
+    "Date2": {
+      "comment": "This is a patient's medical history rating.",
+      "value": "good"
+    },
+    "actualTimeEntered": {
+      "comment": "This is the time that a car enters the toll road.",
+      "value": "'18:50:05'"
+    },
+    "durationParked": {
+      "comment": "This is that a car spent in the parking garage.",
+      "value": "PT25M"
+    }
+  },
+  "formulas": {
+    "comment": "Call each decision table from the 'formulas section'.",
+    "dateResult": {
+      "comment": "This formula calls the tblRiskRating decision table passing two input parameters Date1 and Date 2",
+      "formula": "tblRiskRating(,,Date1, Date2)",
+      "finalValue": []
+    },
+    "tollResult": {
+      "comment": "This formula calls the tblTollTax decision table passing one input parameter, actualTimeEntered, and asks for the toll amount in the result.",
+      "formula": "tblTollTax('toll',,actualTimeEntered)",
+      "finalValue": []
+    },
+    "trafficResult": {
+      "comment": "This formula calls the tblTollTax decision table passing one input parameter, actualTimeEntered, and asks for the traffic category in the result.",
+      "formula": "tblTollTax('traffic',,actualTimeEntered)",
+      "finalValue": []
+    },
+    "durationResult": {
+      "comment": "This formula calls the tblParkingFee decision table passing one input parameter, durationParked.",
+      "formula": "tblParkingFee(,,durationParked)",
+      "finalValue": []
+    }
+  }
+}

package/examples/calculation/DecisionTables/DT Expression example.json

@@ -0,0 +1,32 @@
+{
+  "modelName": "DTExpressionExample",
+  "modelDescription": "RASON Decision Table Example using an Expression: This example illustrates how to utilize duration in an expression in the body of a decision table. The tblParkingFee decision table calculates a fee based on the time spent in a parking garage.",
+  "modelType": "calculation",
+  "data": {
+    "comment": "The input parameter period, use binding to feed dif. values",
+    "period": {
+      "value": "PT25M"
+    }
+  },
+  "decisionTables": {
+    "tblParkingFee": {
+      "comment": "This decision table calculates a parking fee based on the amount of time spent in a parking garage.  The input parameter is the time spent, or the duration.  There are two formats for duration, one measuring periods in months and another measuring periods in seconds. For example, P1DT1H2M3S denotes: P for 'period', 1D for 1 day, T for 'time', 1H for 1 hour, 2M for 2 minutes and 3S for 3 seconds. The output is the parking fee. The fee is generated in the rules portion of the table. For example, if your car is parked in the garage for 90 minutes (PT1H30M), then the parking fee will be 6 * ceiling(duration(PT1H30M)/duration(PT1H)) or 12.  The Hit policy is Unique which means that if more than one rule is successful, an error will be returned.",
+      "inputs": [ "dtDuration" ],
+      "outputs": [ "parkingFee" ],
+      "rules": [
+        [ "<'PT20M'", 0 ],
+        [ "['PT20M'..'PT1H')", "2 *ceiling(duration(dtDuration)/duration('PT20M'))" ],
+        [ "['PT1H'..'PT4H')", "6 *ceiling(duration(dtDuration)/duration('PT1H'))" ],
+        [ ">='PT4H'", "30*ceiling(duration(dtDuration)/duration('P1D'))" ]
+      ],
+      "hitPolicy": "Unique"
+    }
+  },
+  "formulas": {
+    "comment": "The res formula computes a parking fee by calling the tblParkingFee decision table while passing the input parameter, period or PT25M (25 minutes).",
+    "res": {
+      "formula": "tblParkingFee(,,period)",
+      "finalValue": []
+    }
+  }
+}

package/examples/calculation/DecisionTables/DT Hit Policy examples.json

@@ -0,0 +1,137 @@
+{
+  "modelName": "DTHitPolicyExample",
+  "modelDescription": "RASON Decision Table Hit Policy Example: This example illustrates the use of all 7 Hit Policies supported by RASON Decision Services:  Unique, Any, Priority, First, Rule Order, Output Order, & Collect. See each table descriptions for more information.",
+  "modelType": "calculation",
+  "decisionTables": {
+    "comment": "There are 7 decision tables each illustrating a different hit policy.",
+    "tblPolicyAny": {
+      "comment": "The tblPolicyAny decision table showcases the Any hit policy:  If rules overlap, but point to the sae result, that uniqe result is returned. This table takes three input parameters, creditRating, creditCardBalance and studentLoanBalance and returns a loanCompliance rating of 'compliant' or 'not compl'.  For example, if a person with a B credit rating and a loan of 15,000 would trigger the 2nd and 3rd rules. However, since both rules return 'not compl', no error is reported.",
+      "inputs": [ "creditRating", "creditCardBalance", "studentLoanBalance" ],
+      "outputs": [ "loanCompliance" ],
+      "rules": [
+        [ "A", "<10000", "<50000", "compliant" ],
+        [ "Not(A)", "-", "-", "not compl" ],
+        [ "-", ">=10000", "-", "not compl" ],
+        [ "-", "-", ">=50000", "not compl" ]
+      ],
+      "hitPolicy": "A"
+    },
+    "tblPolicyCollect": {
+      "comment": "The tblPolicyCollect decision table exhibits the C+ hit policy:  If multiple rules are hit, return the collection of total of the results, in the rule order. This table accepts two input parameters of type number, age and service, and returns the number of vacation days that an employee is eligible to use.  For example, a 58 year old employee with 31 years of service would qualify for 30 vacation days, or 22 (from rule 1) + 3 (from rule 3) + 5 (from rule 6).",
+      "inputs": [ "age", "service" ],
+      "outputs": [ "holidays" ],
+      "inputTypes": [ "number", "number" ],
+      "outputTypes": [ "number" ],
+      "rules": [
+        [ "-", "-", 22 ],
+        [ ">=60", "-", 3 ],
+        [ "-", ">=30", 3 ],
+        [ "<18", "-", 5 ],
+        [ ">=65", "-", 5 ],
+        [ "-", ">=30", 5 ],
+        [ "[18..60]", "[15..30]", 2 ],
+        [ "[45..60]", "<30", 2 ]
+      ],
+      "hitPolicy": "C+"
+    },
+    "tblPolicyUnique": {
+      "comment": "The tblPolicyUnique decision table exhibits the Unique hit policy:  A unique rule must be triggered evaluating to a unique result.  If multiple rules are triggered, an error will be returned. This table accepts two input parameters, age and medHistory, and a patient's health risk rating and the rule that was triggered. For example, a 54 year old employee with good health rating would be labeled as medium health risk by triggering Rule 3.",
+      "inputs": [ "age", "medHistory" ],
+      "outputs": [ "riskRating", "rule" ],
+      "rules": [
+        [ ">60,<25", "good", "medium", "r1" ],
+        [ ">60", "bad", "high", "r2" ],
+        [ "[25..60]", "-", "medium", "r3" ],
+        [ "<25", "good", "low", "r4" ],
+        [ "<25", "bad", "medium", "r5" ]
+      ],
+      "hitPolicy": "U"
+    },
+    "tblPolicyFirst": {
+      "comment": "The tblPolicyFirst decision table employes the First hit policy: Only 1 result is returned for this policy.  Once a rule is evaluated successfully, or a rule is triggered, the search stops.  This table accepts three input parameters: order, location and customer, and a discount percentage is returned. For example, a web order from Germany would result in a 0% discount, triggered by rule 3. Once a rule is triggered, the search is stopped even though Rule 4 would also apply.",
+      "inputs": [ "order", "location", "customer" ],
+      "outputs": [ "discount" ],
+      "rules": [
+        [ "web", "US", "wholesaler", 10 ],
+        [ "phone", "-", "-", 2 ],
+        [ "-", "non_US", "-", 0 ],
+        [ "-", "-", "retailer", 5 ]
+      ],
+      "hitPolicy": "F"
+    },
+    "tblPolicyRuleOrder": {
+      "comment": "The tblPolicyRuleOrder decision table employes the Rule Order hit policy: If multiple rules are hit, return the collection of results as created in the rule order.  This table accepts three input parameters: gpa, act_count and honor_member, and two outputs will be returned, eligibility and the rule number(s) triggered. For example, a child with a 3.6 GPA, an ACT_count = 4 and an honor student will return the result 20% scholar from r1 and 30% work from r2.",
+      "inputs": [ "gpa", "act_count", "honor_member" ],
+      "outputs": [ "eligibility", "rule" ],
+      "refTypes": [ "number", "number", "boolean", "text", "text" ],
+      "rules": [
+        [ ">3.5", ">=4", true, "20% scholar", "r1" ],
+        [ ">3.0", "-", true, "30% loan", "r2" ],
+        [ ">3.0", ">=2", false, "20% work", "r3" ],
+        [ "<=3.0", "-", "-", "20% work", "r4" ]
+      ],
+      "hitPolicy": "R"
+    },
+    "tblPolicyOutputOrder": {
+      "comment": "The tblPolicyRuleOrder decision table employes the Output Order hit policy: If multiple rules are hit, return the collection of results in the priority order of the listed output values.  This table accepts two input parameters: age and service, and returns the number of vacation days that an employee is eligle to receive. For example, a 59 year old employee with 31 years of service is entitled to 29 vacation days or 27 (rule 1) + 5 (rule 6) + 3 (rule 3). Notice that the vacation days are not listed in rule order but priority value as given by the order of the outputValues.",
+      "inputs": [ "age", "service" ],
+      "outputs": [ "holidays" ],
+      "outputValues": [ "27", "5", "3", "2" ],
+      "rules": [
+        [ "-", "-", "age - service" ],
+        [ ">=60", "-", 3 ],
+        [ "-", ">=30", 3 ],
+        [ "<18", "-", 5 ],
+        [ ">=60", "-", 5 ],
+        [ "-", ">=30", 5 ],
+        [ "[18..60]", "[15..30]", 2 ],
+        [ "[45..60]", "<30", 2 ]
+      ],
+      "hitPolicy": "O"
+    },
+    "tblPolicyPriorityOrder": {
+      "comment": "The tblPolicyRuleOrder decision table employs the Priority Order hit policy: If multiple rules are triggered and multiple results collected, return only one result with the highest priority; the priorities are defined by the order of the output values. This table accepts two input parameters: age and medHistory (medical history), and returns a patient's medical risk rating. For example, a 61 year old employee with a bad medical history would receive a risk rating of medium. Note that two rules are triggered, the 2nd and third. The 2nd has a risk rating of high but the 3rd has a risk rating of medium.  Medium is returned because it is given higher priority in the outputValues.",
+      "inputs": [ "age", "medHistory" ],
+      "outputs": [ "riskRating" ],
+      "refTypes": [ "", "", "" ],
+      "outputValues": [ "low", "medium", "high" ],
+      "rules": [
+        [ ">=25", "good", "medium" ],
+        [ ">60", "bad", "high" ],
+        [ "-", "bad", "medium" ],
+        [ "<25", "good", "low" ]
+      ],
+      "hitPolicy": "P"
+    }
+  },
+  "formulas": {
+    "Any": {
+      "formula": "tblPolicyAny(,,'B', 12000, 75000)",
+      "finalValue": []
+    },
+    "Collect": {
+      "formula": "tblPolicyCollect(,,58, 31)",
+      "finalValue": []
+    },
+    "Unique": {
+      "formula": "tblPolicyUnique(,,54, 'good')",
+      "finalValue": []
+    },
+    "First": {
+      "formula": "tblPolicyFirst(,,'web', 'non_US', 'retailer')",
+      "finalValue": []
+    },
+    "Rule_Order": {
+      "formula": "tblPolicyRuleOrder('eligibility',,3.6, 4, TRUE)",
+      "finalValue": []
+    },
+    "Output_Order": {
+      "formula": "tblPolicyOutputOrder(,,58, 31)",
+      "finalValue": []
+    },
+    "Priority_Order": {
+      "formula": "tblPolicyPriorityOrder(,,61, 'bad')",
+      "finalValue": []
+    }
+  }
+}

package/examples/calculation/DecisionTables/DT Loan Recommend model.json

@@ -0,0 +1,82 @@
+{
+  "modelName": "DTLoanRecommendExample",
+  "modelDescription": "RASON Decision Table Example: The decision table tblLoanTypes, returns a loan that meets the criteria passed in the loanTypes formula (within the formula section). A data table, bankRates, has been entered into the data section. This table lists various banks offering the types of loans listed in the rules section of the tblLoanTypes decision table. For example, AimLoan bank offers a conventional ARM 3/1 loan with a term of 360 months, APR of 3.103, requiring a 20% down payment. The loanTypes formula returns the loans meeting the criteria passed. The formula 'recom' (in the formula section), joins the results for 'loanTypes' with the data table, bankRates. The result for loanTypes is a table containing two loans an ARM 3/1 loan and a Fixed 40 loan.  The PsiJoin function matches these two loans with the loans from the bankRates table to return several ARM 3/1 loans from various banks.  (Since no bank offers the Fixed 40 loan, no results are returned for this loan.) For a complete walkthrough of this example, see the Decision Table chapter within Analytic Solver User Guide.",
+  "modelType": "calculation",
+  "decisionTables": {
+    "comment": "This decision table accepts 4 input parameters:  reqObj, reqType, conforming and reqDown.  In return, the table returns 3 outputs:  loanType, conftype and downPct. The property 'inputTypes' and 'outputTypes' properties specify the types for each input and output parameter. There is only 1 option for the first input, reqObj, 'payment'. If anything other than payment is entered for the first input parameter, an error will be returned. The 2nd input type, reqType, can be anything.  The 3rd input type, conforming, must be either 0 or 1, a boolean value.  The 4th input parameter reqDown, must be a number, but there are no limitations on the value. The 1st output value can be anything. The 2nd output value must be either 'conventional' or 'jumbo'. The 3rd output value must be a number but no limitation has been placed on the value. The rules section contains a list of loans available in the financial sector. The Hit Policy is Collect + which means that all results from all triggered rules will be returned.",
+    "tblLoanTypes": {
+      "inputs": [ "reqObj", "reqType", "conforming", "reqDown" ],
+      "outputs": [ "loanType", "confType", "downPct" ],
+      "inputTypes": [ "", "", "boolean", "number" ],
+      "outputTypes": [ "", "", "number" ],
+      "inputValues": [
+        [ "payment", "", "", "" ]
+      ],
+      "outputValues": [
+        [ "", "conventional", "" ],
+        [ "", "jumbo", "" ]
+      ],
+      "rules": [
+        [ "payment", "Fixed 30, Fixed 20", "-", "<20.0", "'ARM 3/1'", "conventional", 20 ],
+        [ "payment", "Fixed 30, Fixed 20", false, ">=20", "'ARM 3/1'", "jumbo", "reqDown" ],
+        [ "payment", "Fixed 30, Fixed 20", true, ">=20", "'ARM 3/1'", "conventional", "reqDown" ],
+        [ "payment", "Fixed 15", "-", "<20", "Fixed 20", "conventional", 20 ],
+        [ "payment", "Fixed 15", false, ">=20", "Fixed 20", "jumbo", "reqDown" ],
+        [ "payment", "Fixed 15", true, ">=20", "Fixed 20", "conventional", "reqDown" ],
+        [ "payment", "Fixed 20", "-", "<20", "Fixed 30", "conventional", 20 ],
+        [ "payment", "Fixed 20", false, ">=20", "Fixed 30", "jumbo", "reqDown" ],
+        [ "payment", "Fixed 20", true, ">=20", "Fixed 30", "conventional", "reqDown" ],
+        [ "payment", "Fixed 30", "-", "<20", "Fixed 40", "conventional", 20 ],
+        [ "payment", "Fixed 30", false, ">=20", "Fixed 40", "jumbo", "reqDown" ],
+        [ "payment", "Fixed 30", true, ">=20", "Fixed 40", "conventional", "reqDown" ],
+        [ "payment", "'ARM 7/1','ARM 3/1'", "-", "<20", "'ARM 3/1'", "conventional", 20 ],
+        [ "payment", "'ARM 7/1','ARM 3/1'", false, ">=20", "'ARM 3/1'", "jumbo", "reqDown" ],
+        [ "payment", "'ARM 7/1','ARM 3/1'", true, ">=20", "'ARM 3/1'", "conventional", "reqDown" ]
+      ],
+      "hitPolicy": "C"
+    }
+  },
+  "data": {
+    "comment": "The data section is used to organize all constant data params in the RASON model.",
+    "reqObj": {
+      "value": "payment",
+      "comment": "reqobj"
+    },
+    "loanType": {
+      "value": "fixed 30",
+      "comment": "reqtype"
+    },
+    "conforming": {
+      "value": true,
+      "comment": "conforming"
+    },
+    "dwnPct": {
+      "value": 30,
+      "comment": "reqdown"
+    },
+    "bankRates": {
+      "value": [
+        [ "Lender", "loanType", "confType", "minDown%", "Term", "APR%", "Rate%", "Points", "feesAmt" ],
+        [ "MDL", "'ARM 3/1'", "conventional", 20, 360, 3.002, 3, 0, 0 ],
+        [ "AL", "'ARM 3/1'", "conventional", 20, 360, 3.103, 2.875, 0, 1995 ],
+        [ "AO", "'ARM 3/1'", "conventional", 20, 360, 3.13, 2.875, 1, 899 ],
+        [ "MDL", "Fixed 30", "conventional", 20, 360, 3.629, 3.625, 0, 0 ],
+        [ "AL", "Fixed 30", "conventional", 20, 360, 3.682, 3.625, 0, 1068 ],
+        [ "AO", "Fixed 30", "conventional", 20, 360, 3.79, 3.75, 0, 799 ]
+      ]
+    }
+  },
+  "formulas": {
+    "comment": "Use the formulas section to calculate a decision table.",
+    "loanTypes": {
+      "comment": "This formula calls the tblLoanTypes decision table. The first argument [string ret_output] is an optional argument that, when passed, returns only the desired columns in the output. In this example, this argument is blank. The second argument [bool ret_header] is an optional argument that, when True, returns the column headings in the output. This is key since the PsiJoin function is used in the next formula.  The PsiJoin function relies on the column headings in order to perform the combination of the two tables. The third and remaining arguments pass the input parameters to the decision table: reqObj, loanType, conforming and downPct.",
+      "formula": "tblLoanTypes(, true, reqObj, loanType, conforming, dwnPct)",
+      "finalValue": []
+    },
+    "recom": {
+      "comment": "The formula uses the PsiJoin() function to join the loanTypes result with the bankRates array.  This function takes three arguments, Table1, Table2 and Clause.  The Table1 argument passes the first table, tblLoanTypes.  The Table2 argument passes the second table or array, bankRates.  The third argument, Clause, passes the conditions for joining the two.  In this example, loanTypes (the decision table results) and the data table bankRates are joined via three columns:  loanType, confType and downPct.  The Clause argument must be surround by quotes.  ",
+      "formula": "PsiJoin(loanTypes, bankRates, 'loanType = loanType, confType = confType, downPct >= minDown%')",
+      "finalValue": []
+    }
+  }
+}