! | Database.Data |
.&&. | Domain.Logic.Views |
.->. | Domain.Logic.Views |
.<->. | Domain.Logic.Views |
.== | Bayes.Evidence |
.=~ | Bayes.Evidence |
.||. | Domain.Logic.Views |
// | Util.String |
<! | Recognize.Data.Attribute |
<!> | Recognize.SubExpr.Symbols |
<&> | Recognize.SubExpr.Symbols |
<<?> | Recognize.Model.Connectives |
<=> | Domain.Logic.Utils |
<?> | Recognize.SubExpr.Symbols |
<?>> | Recognize.Model.Connectives |
<||> | Recognize.Model.Connectives |
<~> | Recognize.Model.Connectives |
=/= | Domain.Math.Power.Utils |
=== | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Domain.Math.Power.Utils |
3 (Function) | Recognize.Expr.Normalform |
==> | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Recognize.Model.Connectives |
>*< | Recognize.Parsing.Interpretation |
>+< | Recognize.Parsing.Interpretation |
>-< | Recognize.Parsing.Interpretation |
>/< | Recognize.Parsing.Interpretation |
>>*<< | Recognize.Parsing.Interpretation |
>>+<< | Recognize.Parsing.Interpretation |
>>/<< | Recognize.Parsing.Interpretation |
>^< | Recognize.Parsing.Interpretation |
abcBuggyRules | Domain.Math.Polynomial.BuggyRules |
abcFormula | Domain.Math.Polynomial.Rules |
acExpr | Domain.Math.CleanUp |
Add | Recognize.Data.Op |
add | Domain.LinearAlgebra.Matrix |
add2C | Task.MagicTrick.Assess |
add8C | Task.MagicTrick.Assess |
addAttribute | Recognize.Data.Step, Recognize.Data.Diagnosis |
addAttributes | Recognize.Data.Step |
addCell | Util.TableData |
addCol | Util.TableData |
addExponents | Domain.Math.Power.Rules |
addMatching | Recognize.SubExpr.SEParser |
addModelToLatestRequest | Bayes.Script |
addNode | Bayes.Network |
addRow | |
1 (Function) | Domain.LinearAlgebra.Matrix |
2 (Function) | Util.TableData |
addVirtualNodes | Bayes.Evidence |
addWildcardConstraint | Recognize.Parsing.Interpretation |
addXC | Task.MagicTrick.Assess |
adjust | Database.Data |
adviseMeDr | Service.AdviseMe |
aggregateConcepts | Bayes.Script |
aggregateConcepts' | Bayes.Script |
alg | Domain.Math.Numeric.Rules |
Algebraic | Recognize.Data.Approach |
allEvidence | Database.Data |
allEvidenceStudents | Database.Data |
allHumanAssessments | Database.Data |
allM | Util.Monad |
allowedWords | Recognize.Parsing.MathLexer |
allPartialModels | Database.Data |
allPowerFactors | Domain.Math.Polynomial.Rules |
allProbabilities | Bayes.Evidence |
allRecords | Database.Data |
allStudentModels | Database.Data |
alternativesExpr | Recognize.SubExpr.Functions |
Analyzer | Recognize.Data.MathStoryProblem |
analyzer | Recognize.Data.MathStoryProblem |
analyzers | Recognize.Data.MathStoryProblem |
ancestors | Bayes.Network |
andRules | Domain.Logic.Strategies |
andSymbol | Recognize.SubExpr.Symbols |
andView | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Domain.Logic.Views |
ans1 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.RectangleArea |
3 (Function) | Task.Network.Pattern |
4 (Function) | Task.Network.Matryoshka |
5 (Function) | Task.Network.MakingASquare |
6 (Function) | Task.Network.MagicTrick |
7 (Function) | Task.Network.CarRental |
8 (Function) | Task.Network.AreaOfATriangle |
9 (Function) | Task.Network.AreaAndExpression |
ans1Strat | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MakingASquare |
5 (Function) | Task.Network.MagicTrick |
6 (Function) | Task.Network.CarRental |
7 (Function) | Task.Network.AreaAndExpression |
ans1Strat1Step1 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.RectangleArea |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MakingASquare |
5 (Function) | Task.Network.MagicTrick |
6 (Function) | Task.Network.CarRental |
7 (Function) | Task.Network.AreaOfATriangle |
ans1Strat1Step11 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.AreaAndExpression |
ans1Strat1Step12 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.AreaAndExpression |
ans1Strat1Step1Path | Task.Network.Pattern |
ans1Strat1Step2 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MakingASquare |
5 (Function) | Task.Network.MagicTrick |
6 (Function) | Task.Network.CarRental |
7 (Function) | Task.Network.AreaOfATriangle |
ans1Strat1Step3 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MakingASquare |
3 (Function) | Task.Network.MagicTrick |
ans1Strat1Step31 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step32 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step3Path | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step4 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MakingASquare |
3 (Function) | Task.Network.MagicTrick |
ans1Strat1Step41 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step42 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step5 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MakingASquare |
3 (Function) | Task.Network.MagicTrick |
ans1Strat1Step51 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step52 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.CarRental |
ans1Strat1Step6 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.MakingASquare |
3 (Function) | Task.Network.MagicTrick |
4 (Function) | Task.Network.CarRental |
ans1Strat2Step1 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MakingASquare |
5 (Function) | Task.Network.MagicTrick |
6 (Function) | Task.Network.CarRental |
ans1Strat2Step2 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MakingASquare |
5 (Function) | Task.Network.MagicTrick |
6 (Function) | Task.Network.CarRental |
ans1Strat2Step3 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.Matryoshka |
3 (Function) | Task.Network.MakingASquare |
4 (Function) | Task.Network.MagicTrick |
5 (Function) | Task.Network.CarRental |
ans1Strat2Step4 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MagicTrick |
ans1Strat2Step5 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MagicTrick |
ans1Strat2Step6 | |
1 (Function) | Task.Network.Matryoshka |
2 (Function) | Task.Network.MagicTrick |
ans1Strat2Step7 | Task.Network.MagicTrick |
ans1Strat3Step1 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MagicTrick |
ans1Strat3Step10 | Task.Network.Matryoshka |
ans1Strat3Step11 | Task.Network.Matryoshka |
ans1Strat3Step2 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
4 (Function) | Task.Network.MagicTrick |
ans1Strat3Step3 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
ans1Strat3Step4 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.Pattern |
3 (Function) | Task.Network.Matryoshka |
ans1Strat3Step5 | |
1 (Function) | Task.Network.Pattern |
2 (Function) | Task.Network.Matryoshka |
ans1Strat3Step6 | Task.Network.Matryoshka |
ans1Strat3Step7 | Task.Network.Matryoshka |
ans1Strat3Step8 | Task.Network.Matryoshka |
ans1Strat3Step9 | Task.Network.Matryoshka |
ans1Strat4Step1 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.MagicTrick |
ans1Strat4Step2 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.MagicTrick |
ans1Strat4Step3 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.MagicTrick |
ans1Strat4Step4 | Task.Network.MagicTrick |
ans1Strat4Step5 | Task.Network.MagicTrick |
ans1Strat4Step6 | Task.Network.MagicTrick |
ans1Strat4Step7 | Task.Network.MagicTrick |
ans2 | |
1 (Function) | Task.Network.TheatreRate |
2 (Function) | Task.Network.RectangleArea |
3 (Function) | Task.Network.AreaOfATriangle |
ans2Strat | Task.Network.TheatreRate |
ans2Strat1Step1 | |
1 (Function) | Task.Network.TheatreRate |
2 (Function) | Task.Network.AreaOfATriangle |
ans2Strat1Step11 | Task.Network.RectangleArea |
ans2Strat1Step12 | Task.Network.RectangleArea |
ans2Strat1Step13 | Task.Network.RectangleArea |
ans2Strat1Step14 | Task.Network.RectangleArea |
ans2Strat1Step2 | |
1 (Function) | Task.Network.RectangleArea |
2 (Function) | Task.Network.AreaOfATriangle |
ans2Strat1Step21 | Task.Network.TheatreRate |
ans2Strat1Step22 | Task.Network.TheatreRate |
ans2Strat1Step3 | Task.Network.TheatreRate |
ans2Strat1Step41 | Task.Network.TheatreRate |
ans2Strat1Step42 | Task.Network.TheatreRate |
ans2Strat1Step4Path | Task.Network.TheatreRate |
ans2Strat1Step51 | Task.Network.TheatreRate |
ans2Strat1Step52 | Task.Network.TheatreRate |
ans2Strat1Step61 | Task.Network.TheatreRate |
ans2Strat1Step62 | Task.Network.TheatreRate |
ans2Strat1Step7 | Task.Network.TheatreRate |
ans2Strat2Step1 | Task.Network.TheatreRate |
ans2Strat2Step2 | Task.Network.TheatreRate |
ans2Strat2Step3 | Task.Network.TheatreRate |
ans3 | |
1 (Function) | Task.Network.RectangleArea |
2 (Function) | Task.Network.AreaOfATriangle |
ans3Strat | Task.Network.AreaOfATriangle |
ans3Strat1Step1 | |
1 (Function) | Task.Network.RectangleArea |
2 (Function) | Task.Network.AreaOfATriangle |
ans3Strat1Step2 | Task.Network.AreaOfATriangle |
ans3Strat1Step3 | Task.Network.AreaOfATriangle |
ans3Strat2Step1 | Task.Network.AreaOfATriangle |
ans3Strat2Step2 | Task.Network.AreaOfATriangle |
ans3Strat2Step3 | Task.Network.AreaOfATriangle |
answerCorrect | Recognize.Model.Assess |
anyM | Util.Monad |
appLast | Util.List |
applyFirstM | Util.Monad |
applyMap | Recognize.Preprocessing |
Approach | Recognize.Data.Approach |
approach | Recognize.Data.Approach |
approx | Recognize.Expr.Symbols |
Approximation | |
1 (Type/Class) | Domain.Math.Approximation |
2 (Data Constructor) | Recognize.Data.Attribute |
approxRelView | Recognize.Strategy.Views |
approxSymbol | Recognize.Expr.Symbols |
arbitraryPrintable | Recognize.Data.Math |
Area | Recognize.Data.Attribute |
areaAndExpression | Task.AreaAndExpression |
areaOfATriangle | Task.AreaOfATriangle |
Arithmetic | Recognize.Data.Approach |
ARule | Recognize.Data.Attribute |
ARuleR | Recognize.Data.Attribute |
asciiTable | Main.Diagnose |
assess' | |
1 (Function) | Task.VPattern.Assess |
2 (Function) | Task.TheatreRate.Assess |
3 (Function) | Task.Pattern.Assess |
4 (Function) | Task.Matryoshka.Assess |
5 (Function) | Task.MagicTrick.Assess |
assocExpr | Domain.Math.CleanUp |
associateToRight | Domain.Logic.Parser |
assocPlus | Domain.Math.CleanUp |
assocTimes | Domain.Math.CleanUp |
asString | Recognize.Data.Math |
AsymmetricRelation | Recognize.Data.Attribute |
AtomMixedUp | Recognize.Data.Attribute |
Attribute | Recognize.Data.Attribute |
backward | Domain.LinearAlgebra.Matrix |
balanced | Util.Parentheses |
balanceExercise | Domain.Math.Polynomial.Balance |
balanceOrder | Domain.Math.Polynomial.Balance |
balanceStrategy | Domain.Math.Polynomial.Balance |
bigStep | Recognize.Data.Step |
binomialPolyView | Domain.Math.Polynomial.Views |
bisection | Domain.Math.Approximation |
breaksOn | Util.String |
bringAToOne | Domain.Math.Polynomial.Rules |
buggyBalanceExprRule | Domain.Math.Polynomial.BalanceUtils |
buggyBalanceExprRules | Domain.Math.Polynomial.BuggyBalance |
buggyBalanceRecognizer | Domain.Math.Polynomial.BalanceUtils |
buggyBalanceRule | Domain.Math.Polynomial.BalanceUtils |
buggyBalanceRuleArg | Domain.Math.Polynomial.BalanceUtils |
buggyBalanceRules | Domain.Math.Polynomial.BuggyBalance |
buggyPriority | Domain.Math.Polynomial.BuggyBalance |
buggyQuadratic | Domain.Math.Polynomial.BuggyRules |
buggyRules | Domain.Logic.BuggyRules |
buggyRulesEquation | Domain.Math.Polynomial.BuggyRules |
buggyRulesExpr | Domain.Math.Polynomial.BuggyRules |
buggySquareMultiplication | Domain.Math.Polynomial.BuggyRules |
buggySymbol | Recognize.SubExpr.Symbols |
buildEvidence | Recognize.Model.EvidenceBuilder |
buildStepsEvidence | |
1 (Function) | Task.VPattern.Assess |
2 (Function) | Task.TheatreRate.Assess |
3 (Function) | Task.Pattern.Assess |
4 (Function) | Task.Matryoshka.Assess |
5 (Function) | Task.MagicTrick.Assess |
buildStudentReport | Bayes.StudentReport |
cached | Util.Cache |
cached2 | Util.Cache |
cached3 | Util.Cache |
cached4 | Util.Cache |
calcBinRule | Domain.Math.Numeric.Rules |
calcDivisionWith | Domain.Math.Numeric.Rules |
calcMinusWith | Domain.Math.Numeric.Rules |
calcPlainRoot | Domain.Math.Power.Rules |
calcPlusWith | Domain.Math.Numeric.Rules |
calcPower | Domain.Math.Power.Rules |
calcPowerMinus | Domain.Math.Power.Rules |
calcPowerPlus | Domain.Math.Power.Rules |
calcPowerRatio | Domain.Math.Power.Rules |
calcRuleName | Domain.Math.Numeric.Rules |
calcTimesWith | Domain.Math.Numeric.Rules |
calculate | Domain.Math.Polynomial.Balance |
calculatePriors | Database.Priors |
cancelTerms | Domain.Math.Polynomial.Rules |
cancelTermsDiv | Domain.Math.Polynomial.RationalRules |
CapturedWildcard | Recognize.Data.Attribute |
carRental | Task.CarRental |
cartProd | Util.List |
category | Recognize.Data.Diagnosis |
categoryAsString | Recognize.Data.Entry |
categoryStatistics | Main.Diagnose |
ceilingExpr | Recognize.Expr.Normalform |
Cell | Main.ParserCSV |
chainedEqSymbol | Recognize.Data.Math |
chainedEquations | Recognize.SubExpr.SEParser |
changeEntries | Domain.LinearAlgebra.Matrix |
changeEntry | Domain.LinearAlgebra.Matrix |
changeOp | Recognize.Expr.Functions |
changeSet | Recognize.Expr.Functions |
checkForChange | Domain.Math.Polynomial.BalanceUtils |
checkSolution | Domain.Math.Polynomial.RationalRules |
choice | Recognize.Parsing.Derived |
choice' | Recognize.Parsing.Derived |
choiceFor | Recognize.Parsing.Derived |
choiceFor' | Recognize.Parsing.Derived |
cleaner | Domain.Math.Polynomial.BalanceUtils |
cleanerExpr | Domain.Math.Polynomial.BalanceUtils |
cleanExpr | Recognize.SubExpr.Functions |
cleanUpACView | Domain.Math.CleanUp |
cleanUpExpr | Domain.Math.CleanUp |
cleanUpRelation | Domain.Math.CleanUp |
cleanUpRelations | Domain.Math.CleanUp |
cleanUpSimple | Domain.Math.CleanUp |
cleanUpView | Domain.Math.CleanUp |
clear | Bayes.Evidence |
clearWildcard | Recognize.Parsing.Interpretation |
closestInList | Recognize.Expr.Functions |
cnfStrategy | Domain.Logic.Strategies |
colHeaders | Util.TableData |
collect | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Domain.Math.Polynomial.Balance |
collectGlobal | Domain.Math.Polynomial.BalanceUtils |
collectIDs | Database.Data |
collectInputs | Database.Data |
collectLikeTerms | Domain.Math.Simplification |
collectLocal | Domain.Math.Polynomial.BalanceUtils |
collector | Recognize.Data.MathStoryProblem |
collectSolution | Database.Data |
collectSource | Database.Data |
Collect_Num | Recognize.Data.RuleId |
Collect_Var | Recognize.Data.RuleId |
Color | Bayes.SVG |
Column | |
1 (Type/Class) | Domain.LinearAlgebra.Matrix |
2 (Data Constructor) | Recognize.Data.StringLexer |
column | Domain.LinearAlgebra.Matrix |
columns | |
1 (Function) | Domain.LinearAlgebra.Matrix |
2 (Function) | Database.Data |
combinePredicates | Recognize.Model.Constraint |
commit | Database.Data |
commonFactorVar | Domain.Math.Polynomial.Rules |
commonFactorVarNew | Domain.Math.Polynomial.Rules |
CommonMistake | Recognize.Data.Attribute |
commOp | Domain.Math.Equation.CoverUpRules |
Competence | |
1 (Type/Class) | Bayes.StudentReport |
2 (Data Constructor) | Bayes.StudentReport |
competences | Bayes.StudentReport |
con | Domain.Math.Data.MultivariatePolynomial |
concatMapM | Util.List |
Concept | Recognize.Data.Attribute |
condition | Bayes.Factor |
conditions | Bayes.Factor |
conditionVarsRHS | Domain.Math.Polynomial.Rules |
ConfigCoverUp | Domain.Math.Equation.CoverUpRules |
configCoverUp | Domain.Math.Equation.CoverUpRules |
configName | Domain.Math.Equation.CoverUpRules |
conformsTo | Recognize.SubExpr.SEParser |
conLeftMinus | Domain.Math.Polynomial.Balance |
conLeftPlus | Domain.Math.Polynomial.Balance |
conRight | Domain.Math.Polynomial.Balance |
conRightMinus | Domain.Math.Polynomial.Balance |
conRightPlus | Domain.Math.Polynomial.Balance |
consPowerView | Domain.Math.Power.Views |
constantFolding | Domain.Math.Simplification |
constantPolyView | Domain.Math.Polynomial.Views |
Constraint | |
1 (Type/Class) | Recognize.Model.Constraint |
2 (Data Constructor) | Recognize.Model.Constraint |
convertToLowercase | Recognize.Data.MathParserOptions |
correctResult | Recognize.Data.Diagnosis |
Count | Util.Table |
count | |
1 (Function) | Util.Table |
2 (Function) | Main.Diagnose |
countEntries | Database.Data |
countEntry | Main.Report |
countResult | Main.Report |
countStudentEntries | Database.Data |
countStudents | Database.Data |
countTaskEntries | Database.Data |
coverLHS | Domain.Math.Equation.CoverUpRules |
coverRHS | Domain.Math.Equation.CoverUpRules |
coverUp | Domain.Math.Equation.CoverUpRules |
coverUpBinaryRule | Domain.Math.Equation.CoverUpRules |
coverUpDenominator | Domain.Math.Equation.CoverUpRules |
coverUpDenominatorWith | Domain.Math.Equation.CoverUpRules |
coverUpMinusLeft | Domain.Math.Equation.CoverUpRules |
coverUpMinusLeftWith | Domain.Math.Equation.CoverUpRules |
coverUpMinusRight | Domain.Math.Equation.CoverUpRules |
coverUpMinusRightWith | Domain.Math.Equation.CoverUpRules |
coverUpNegate | Domain.Math.Equation.CoverUpRules |
coverUpNegateWith | Domain.Math.Equation.CoverUpRules |
coverUpNumerator | Domain.Math.Equation.CoverUpRules |
coverUpNumeratorWith | Domain.Math.Equation.CoverUpRules |
coverUpOrs | Domain.Math.Equation.CoverUpRules |
coverUpPlus | |
1 (Function) | Domain.Math.Equation.CoverUpRules |
2 (Function) | Recognize.Strategy.Strategies |
coverUpPlusWith | Domain.Math.Equation.CoverUpRules |
coverUpPower | Domain.Math.Equation.CoverUpRules |
coverUpPowerWith | Domain.Math.Equation.CoverUpRules |
coverUpRules | Domain.Math.Equation.CoverUpRules |
coverUpRulesOr | Domain.Math.Equation.CoverUpRules |
coverUpRulesX | Domain.Math.Power.Utils |
coverUpSqrt | Domain.Math.Equation.CoverUpRules |
coverUpSqrtWith | Domain.Math.Equation.CoverUpRules |
coverUpTimes | Domain.Math.Equation.CoverUpRules |
coverUpTimesPositive | Recognize.Strategy.Strategies |
coverUpTimesWith | Domain.Math.Equation.CoverUpRules |
Coverup_OneVar_Plus | Recognize.Data.RuleId |
Coverup_Times_Positive | Recognize.Data.RuleId |
CPT | Bayes.Network |
createTable | Database.Data |
crossMultiply | Domain.Math.Polynomial.RationalRules |
CSV | Main.ParserCSV |
csvTable | Util.TableData |
cubicGen | Domain.Math.Polynomial.Generators |
cubicPolyView | Domain.Math.Polynomial.Views |
DE | Recognize.Data.Solution |
defaultEntry | Database.Data |
defaultModulo | Recognize.Parsing.Interpretation |
defaultRecognizer | Recognize.Recognizer |
defaultSolution | Recognize.Data.Solution |
Definition | |
1 (Type/Class) | Recognize.Data.Definition |
2 (Type/Class) | Bayes.Network |
3 (Data Constructor) | Recognize.SubExpr.SEParser |
definition | Bayes.Network |
definitionView | Recognize.Data.Definition |
defPowerNat | Domain.Math.Polynomial.Rules |
deleteByM | Util.Monad |
deMorgan | Domain.Logic.Strategies |
deMorganAnd | Domain.Logic.Strategies |
deMorganOr | Domain.Logic.Strategies |
derivative | Domain.Math.Approximation |
descendants | Bayes.Network |
determineInputType | Recognize.SubExpr.SEParser |
diagnose | Recognize.Data.MathStoryProblem |
DiagnoseError | Recognize.Data.DiagnoseError |
diagnoseMultiple | Main.Diagnose |
DiagnoseResult | |
1 (Type/Class) | Recognize.Data.DiagnoseResult |
2 (Data Constructor) | Recognize.Data.DiagnoseResult |
diagnoses | Recognize.Data.Entry |
diagnoseSingle | Main.Diagnose |
Diagnosis | |
1 (Type/Class) | Recognize.Data.Diagnosis |
2 (Data Constructor) | Recognize.Data.Diagnosis |
diagnosis | Recognize.Data.DiagnoseResult |
DiagnosisReply | |
1 (Type/Class) | Service.Types |
2 (Data Constructor) | Service.Types |
diffPlus | Domain.Math.Polynomial.BalanceUtils |
diffTimes | Domain.Math.Polynomial.BalanceUtils |
Dimensional | Bayes.Factor |
Dimensions | Bayes.Factor |
dimensions | |
1 (Function) | Bayes.Factor |
2 (Function) | Domain.LinearAlgebra.Matrix |
distrAnd | Domain.Logic.Strategies |
distribute | Domain.Math.Polynomial.Balance |
distributeDiv | Domain.Math.Polynomial.BalanceUtils |
distributeDivision | Recognize.Strategy.Rules |
distributeDivisionMulti | Domain.Math.Polynomial.Rules |
distributeDivisionT | Domain.Math.Polynomial.Rules |
distributeExponent | Recognize.Expr.Normalform |
distributePower | Domain.Math.Power.Rules |
distributePowerDiv | Domain.Math.Power.Rules |
distributeTimes | |
1 (Function) | Domain.Math.Polynomial.BalanceUtils |
2 (Function) | Domain.Math.Polynomial.Rules |
distribution | Domain.Math.Simplification |
distributionSquare | Domain.Math.Polynomial.Rules |
distrOr | Domain.Logic.Strategies |
Distr_Division | Recognize.Data.RuleId |
Distr_Times | Recognize.Data.RuleId |
Div | Recognize.Data.Op |
div4C | Task.MagicTrick.Assess |
divBase | Domain.Math.Power.Rules |
divide | Domain.Math.Data.MultivariatePolynomial |
divideCommonFactor | Domain.Math.Polynomial.Balance |
Division | Recognize.Data.RuleId |
divisionDenominator | Domain.Math.Numeric.Rules |
divisionExpr | Domain.Math.Polynomial.LeastCommonMultiple |
divisionIsOne | Domain.Math.Polynomial.RationalRules |
divisionIsZero | Domain.Math.Polynomial.RationalRules |
divisionNegateLeft | Domain.Math.Numeric.Rules |
divisionNegateRight | Domain.Math.Numeric.Rules |
divisionNumerator | Domain.Math.Numeric.Rules |
divisionRule | Domain.Math.Equation.BalanceRules |
divisionToFraction | Domain.Math.Polynomial.Balance |
dnfStrategy | Domain.Logic.Strategies |
doubleNegate | Domain.Math.Numeric.Rules |
doubleRoundedView | Recognize.Expr.Normalform |
dropParensString | Task.MagicTrick.Recognizer |
dropTable | Database.Data |
dropUntil | Domain.Math.Power.Utils |
eliminate | Bayes.Factor |
eliminateImplEquiv | Domain.Logic.Strategies |
eliminateList | Bayes.Factor |
eliminateSplit | Bayes.Factor |
EliminationOrdering | Bayes.EliminationOrdering |
Empty | Recognize.Data.DiagnoseError |
empty | Util.TableData |
emptyConcepts | Bayes.Script |
EN | Recognize.Data.Solution |
enclose | Recognize.Preprocessing |
Entry | |
1 (Type/Class) | Recognize.Data.Entry |
2 (Data Constructor) | Recognize.Data.Entry |
entry | |
1 (Function) | Domain.LinearAlgebra.Matrix |
2 (Function) | Service.Types |
eqComAssoc | Util.Expr |
eqMatrix | Domain.LinearAlgebra.Matrix |
equalFactors | Domain.Math.Polynomial.LeastCommonMultiple |
equalLogicA | Domain.Logic.Generator |
equalLogicACI | Domain.Logic.Generator |
Equation | Recognize.SubExpr.SEParser |
equationSolvedForm | Domain.Math.Equation.Views |
equationSolvedWith | Domain.Math.Equation.Views |
equationsSolvedForm | Domain.Math.Equation.Views |
equivalentStructure | Recognize.Expr.Functions |
eqView | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Domain.Math.Power.Utils |
3 (Function) | Domain.Math.Polynomial.BalanceUtils |
EvBuilder | Recognize.Model.EvidenceBuilder |
Evidence | Bayes.Evidence |
evidence | Recognize.Data.DiagnoseResult |
evidenceIndex | Bayes.Evidence |
evidenceMap | Bayes.Evidence |
evidenceOfAbsence | Bayes.Evidence |
EvidenceType | Bayes.Evidence |
evStates | Bayes.Evidence |
ex | Domain.Math.Data.MultivariatePolynomial |
examinator | Service.Types |
exercise | Service.Types |
exhaustiveSomewhere | Domain.Math.Power.Utils |
exhaustiveStrategy | Domain.Math.Power.Utils |
exhaustiveUse | Domain.Math.Power.Utils |
exists | Recognize.Model.Connectives |
exists1 | Recognize.Model.Connectives |
existsF | Recognize.Model.Connectives |
existsF1 | Recognize.Model.Connectives |
Expand | Recognize.Data.Attribute |
expandExamples | Domain.Math.Polynomial.Examples |
expandOps | Task.MagicTrick.Recognizer |
expectation | Database.HumanAssessment |
expectedAbsence | Database.HumanAssessment |
expectedPresence | Database.HumanAssessment |
expo | Domain.Math.Data.MultivariatePolynomial |
exposeSameFactor | Domain.Math.Polynomial.Rules |
Expr | Recognize.SubExpr.SEParser |
expr | Recognize.Parsing.MathParser |
extract | Recognize.Parsing.MathLexer |
extractMatched | Recognize.SubExpr.Functions |
extraIneqQuad | Domain.Math.Polynomial.Examples |
Factor | Bayes.Factor |
factor1Ref | Domain.Math.Polynomial.BalanceUtils |
factor2Ref | Domain.Math.Polynomial.BalanceUtils |
factorAsPower | Domain.Math.Power.Rules |
factorizeExamples | Domain.Math.Polynomial.Examples |
factorLeftAsSquare | Domain.Math.Polynomial.Rules |
factorRef | Domain.Math.Polynomial.BalanceUtils |
Factors | Domain.Math.Data.MultivariatePolynomial |
factorVariablePower | Domain.Math.Polynomial.Rules |
failOnAnyMistake | Recognize.Model.Assess |
failOnAtomMixedUpAny | Recognize.Model.Assess |
failOnCommonMistake | Recognize.Model.Assess |
failOnIncorrectDistribution | Recognize.Model.Assess |
failOnInvalidEquation | Recognize.Model.Assess |
failOnInvalidEquationAny | Recognize.Model.Assess |
failOnUnequalRelation | Recognize.Model.Assess |
failOnUnequalRelationAny | Recognize.Model.Assess |
Failure | Recognize.Model.Result |
failure | Recognize.Model.Connectives |
fallback | Main.Report |
few | Recognize.Parsing.Derived |
fillInMissedSteps | Task.MagicTrick.Recognizer |
filterEvidence | Bayes.Evidence |
filterNodes | Bayes.Network |
FinalAnswer | Recognize.Data.Attribute |
finalRecords | Database.Data |
findEvidence | Bayes.Script |
findNode | Bayes.Network |
findNodeFuzzy | Bayes.Network |
findProbability | Bayes.Evidence |
findStates | Bayes.Network |
findTask | Main.Tasks |
findTaskFuzzy | Main.Tasks |
findWithDefault | Database.Data |
flipEquation | Domain.Math.Polynomial.Rules |
flipOp | Domain.Math.Equation.CoverUpRules |
flipped | Domain.Math.Polynomial.Balance |
floorExpr | Recognize.Expr.Normalform |
Forget | Recognize.Data.Attribute |
ForgetSym | Recognize.Data.Attribute |
formExpr | Recognize.Data.Op |
forward | Domain.LinearAlgebra.Matrix |
FR | Recognize.Data.Solution |
fractionPlus | |
1 (Function) | Domain.Math.Numeric.Rules |
2 (Function) | Domain.Math.Polynomial.RationalRules |
fractionPlusScale | Domain.Math.Numeric.Rules |
fractionProduct | Domain.Math.Polynomial.Rules |
fractionScale | Domain.Math.Polynomial.RationalRules |
fractionStrategy | Recognize.Strategy.Strategies |
fractionTimes | Domain.Math.Numeric.Rules |
fractionTimesCancelDenNom | Domain.Math.Numeric.Rules |
fractionTimesCancelNomDen | Domain.Math.Numeric.Rules |
fromDefinition | Recognize.Data.Definition |
fromDerivation | Recognize.Strategy.Derivation |
fromDimensions | Bayes.Factor |
fromDouble | Bayes.Probability |
fromEvidence | Bayes.Evidence |
fromEvidenceTp | Bayes.Evidence |
fromFactors | Domain.Math.Data.MultivariatePolynomial |
fromList | Util.TableData |
fromMultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
fromOp | Recognize.Data.Op |
fromOp' | Recognize.Data.Op |
fromOps | Recognize.Data.Op |
fromProbabilities | Bayes.Evidence |
fromRule | Recognize.Strategy.Derivation |
fullNetwork | Main.Tasks |
fullyExpanded | Task.MagicTrick.Assess |
Function | Domain.Math.Approximation |
functionCallSymbol | Recognize.Data.Math |
functionCallWhitelist | Recognize.Data.MathParserOptions |
Generalizing | Recognize.Data.Approach |
generalRuleDeMorganAnd | Domain.Logic.GeneralizedRules |
generalRuleDeMorganOr | Domain.Logic.GeneralizedRules |
generalRuleDistrAnd | Domain.Logic.GeneralizedRules |
generalRuleDistrOr | Domain.Logic.GeneralizedRules |
generalRuleInvDoubleNegAnd | Domain.Logic.GeneralizedRules |
generalRuleInvDoubleNegOr | Domain.Logic.GeneralizedRules |
generateEvidence | Recognize.Model.Assess |
generateLevel | Domain.Logic.Generator |
generateLogic | Domain.Logic.Generator |
get | |
1 (Function) | Recognize.SubExpr.SEParser |
2 (Function) | Util.TableData |
getAttributes | Recognize.Data.Step, Recognize.Data.Diagnosis |
getAttributesPerStep | Recognize.Model.EvidenceBuilder |
getBinary | Recognize.Parsing.Derived |
getChainedEq | Recognize.Data.Math |
getConstraint | Recognize.Model.Constraint |
getEq | Recognize.Data.Math |
getEqE | Recognize.Data.Math |
getEvidence | Database.HumanAssessment |
getExercise | Recognize.Data.MathStoryProblem |
getExpr | Recognize.Data.Math |
getFactors | Bayes.Inference |
getHumanMachineFiles | Database.HumanAssessment |
getIndex | Bayes.Evidence |
getInput | Recognize.Data.Solution |
getInputId | Recognize.Data.Solution |
getInputSize | Recognize.Parsing.Derived |
getLeft | Recognize.Expr.Functions |
getMatched | Recognize.SubExpr.Functions |
getMatchEnvironment | Recognize.Parsing.Interpretation |
getMath | Recognize.Data.Step, Recognize.Data.Diagnosis |
getMaths | Recognize.Data.Step, Recognize.Data.Diagnosis |
getMostLeft | Recognize.Expr.Functions |
getNames | Bayes.Evidence |
getNode | Recognize.Model.Constraint |
getRelation | Recognize.Data.Math |
getRelationE | Recognize.Data.Math |
getResult | |
1 (Function) | Recognize.Model.Constraint |
2 (Function) | Recognize.Data.Math |
getRight | Recognize.Expr.Functions |
gets | Recognize.SubExpr.SEParser |
getSpreadsheet | Database.HumanAssessment |
getString | Recognize.Data.Math |
getTranslations | Bayes.StudentReport |
getValue | Recognize.Data.Step |
getValueOf | Recognize.Model.EvidenceBuilder |
getVar | Recognize.Expr.Functions |
getVariables | Recognize.Model.EvidenceBuilder |
getVarKey | Recognize.SubExpr.SEParser |
getVarS | Recognize.Expr.Functions |
getWildcard | Recognize.Parsing.Interpretation |
giveNode | Recognize.Model.Constraint |
giveNodeAndCollect | Recognize.Model.Assess |
giveNodeAndCollectAll | Recognize.Model.Assess |
giveNodeAndCollectAllKnown | Recognize.Model.Assess |
giveNodeAndCollectDefault | Recognize.Model.Assess |
Graphical | Recognize.Data.Approach |
groupAbsorption | Domain.Logic.Utils |
groupAssociativity | Domain.Logic.Utils |
groupBy' | Util.List |
groupCommutativity | Domain.Logic.Utils |
groupDeMorgan | Domain.Logic.Utils |
groupDistribution | Domain.Logic.Utils |
groupDoubleNegation | Domain.Logic.Utils |
groupEquivalence | Domain.Logic.Utils |
groupFalseComplement | Domain.Logic.Utils |
groupFalseConjunction | Domain.Logic.Utils |
groupFalseDisjunction | Domain.Logic.Utils |
GroupId | Recognize.Data.Solution |
groupId | Recognize.Data.Solution |
groupIdempotency | Domain.Logic.Utils |
groupImplication | Domain.Logic.Utils |
groupings | Util.List |
groupNotFalse | Domain.Logic.Utils |
groupNotTrue | Domain.Logic.Utils |
groupTrueComplement | Domain.Logic.Utils |
groupTrueConjunction | Domain.Logic.Utils |
groupTrueDisjunction | Domain.Logic.Utils |
growF | Recognize.SubExpr.SEParser |
guardBy | Recognize.Parsing.Parse |
guessMagicExpr | Task.MagicTrick.Recognizer |
HalfPerimeter | Recognize.Data.Attribute |
hardEvidence | Bayes.Evidence |
HasApproach | Recognize.Data.Approach |
hasChainedEquations | Recognize.Data.MathParserOutput |
hasCommonality | Task.MagicTrick.Recognizer |
hasExpr | Recognize.Expr.Functions |
hasMagicNat | Recognize.SubExpr.Functions |
hasMagicNumber | Recognize.SubExpr.Functions |
hasMagicVar | Recognize.SubExpr.Functions |
hasMatch | Recognize.SubExpr.Functions |
hasMistakes | Recognize.Data.Step, Recognize.Data.Diagnosis |
hasSub | Recognize.SubExpr.Functions |
hasVar | |
1 (Function) | Recognize.SubExpr.Functions |
2 (Function) | Recognize.Expr.Functions |
hasVarD | Bayes.Factor |
header | Main.Report |
higherDegreeEquationsView | Domain.Math.Polynomial.Views |
higherDegreeExamples | Domain.Math.Polynomial.Examples |
higherSubst | Domain.Math.Polynomial.Rules |
holes | Domain.Math.Power.Utils |
htmlTable | Util.TableData |
identity | Domain.LinearAlgebra.Matrix |
identityMatrix | Domain.LinearAlgebra.Matrix |
ids | Service.Types |
implication | Recognize.Model.Connectives |
Implicit | Recognize.Data.Attribute |
IncorrectDistribution | Recognize.Data.Attribute |
IncorrectFactorization | Recognize.Data.Attribute |
indent | Util.String |
Index | Bayes.Evidence |
index | Util.List |
ineqHigh | Domain.Math.Polynomial.Examples |
ineqLin1 | Domain.Math.Polynomial.Examples |
ineqQuad1 | Domain.Math.Polynomial.Examples |
ineqQuad2 | Domain.Math.Polynomial.Examples |
InequalityStrictness | Recognize.Data.Attribute |
infer | Bayes.Inference |
inferEvidence | Bayes.Inference |
inferNetwork | Bayes.Inference |
initialState | Recognize.Parsing.Interpretation |
inLiberalEquationMode | Recognize.Parsing.Interpretation |
Input | |
1 (Type/Class) | Recognize.Data.Solution |
2 (Data Constructor) | Recognize.Data.Solution |
inputFile | Recognize.Data.MathStoryProblem |
InputID | Database.Data |
InputId | Recognize.Data.Solution |
inputs | Recognize.Data.Solution |
inputToString | Recognize.Data.Solution |
InputType | Recognize.SubExpr.SEParser |
inputType | Recognize.SubExpr.SEParser |
inRowEchelonForm | Domain.LinearAlgebra.Matrix |
inRowReducedEchelonForm | Domain.LinearAlgebra.Matrix |
insert | Database.Data |
insertRecord | Database.Data |
insertRecords | Database.Data |
integerGenerator | Domain.Math.Numeric.Generators |
interpret | Recognize.Parsing.Interpretation |
Interpretation | Recognize.Parsing.Interpretation |
InterpretationParser | Recognize.Parsing.Interpretation |
introFalse | Domain.Math.Polynomial.Balance |
introTrue | Domain.Math.Polynomial.Balance |
InvalidCommutativity | Recognize.Data.Attribute |
InvalidEquation | Recognize.Data.Attribute |
inverse | Domain.LinearAlgebra.Matrix |
inverseAndOverOr | Domain.Logic.InverseRules |
inverseDeMorganAnd | Domain.Logic.InverseRules |
inverseDeMorganOr | Domain.Logic.InverseRules |
inverseIdempAnd | Domain.Logic.InverseRules |
inverseIdempOr | Domain.Logic.InverseRules |
inverseOrOverAnd | Domain.Logic.InverseRules |
inverseRules | Domain.Logic.InverseRules |
InvertedFraction | Recognize.Data.Attribute |
invertible | Domain.LinearAlgebra.Matrix |
isAnd | Recognize.SubExpr.Functions |
isAndSymbol | Recognize.SubExpr.Functions |
isApproximation | Recognize.Data.Attribute |
isAtom | Recognize.Expr.Functions |
isBuggy | Recognize.SubExpr.Functions |
isBuggySymbol | Recognize.SubExpr.Functions |
isChainedEq | Recognize.Data.Math |
isChainedEqSymbol | Recognize.Data.Math |
isCommonMistake | Recognize.Data.Attribute |
isDefinition | Recognize.Data.Math |
isDiv | Recognize.Expr.Functions |
isEmpty | |
1 (Function) | Domain.LinearAlgebra.Matrix |
2 (Function) | Bayes.Evidence |
isEq | Recognize.Data.Math |
isFunctionCall | Recognize.Data.Math |
isFunctionCallSymbol | Recognize.Data.Math |
isFunctionDefinition | Recognize.Data.Math |
isLabel | Recognize.SubExpr.Functions |
isLabelAttr | Recognize.Data.Attribute |
isLabelSymbol | Recognize.SubExpr.Functions |
isLiteral | Util.Expr |
isLowerTriangular | Domain.LinearAlgebra.Matrix |
isLt | Recognize.SubExpr.Functions |
isLtSymbol | Recognize.SubExpr.Functions |
isMagicNat | Recognize.SubExpr.Functions |
isMagicNatSymbol | Recognize.SubExpr.Functions |
isMagicNumber | Recognize.SubExpr.Functions |
isMagicNumberSymbol | Recognize.SubExpr.Functions |
isMagicVar | Recognize.SubExpr.Functions |
isMagicVarSymbol | Recognize.SubExpr.Functions |
isMatch | Recognize.SubExpr.Functions |
isMatched | Recognize.SubExpr.Functions |
isMatchSymbol | Recognize.SubExpr.Functions |
isMistake | Recognize.Data.Attribute |
isNamedWildcardSymbol | Recognize.Expr.Symbols |
isNat | Recognize.Expr.Functions |
isNormalformSymbol | Recognize.Expr.Symbols |
isNoSim | Recognize.SubExpr.Functions |
isNoSimSymbol | Recognize.SubExpr.Functions |
isNumber | Recognize.Expr.Functions |
isOr | Recognize.SubExpr.Functions |
isOrSymbol | Recognize.SubExpr.Functions |
isParseError | Recognize.Data.Math |
isPivotColumn | Domain.LinearAlgebra.Matrix |
isPlusT | Domain.Math.Polynomial.BalanceUtils |
isRectangular | Domain.LinearAlgebra.Matrix |
isSim | Recognize.SubExpr.Functions |
isSimplified | Recognize.SubExpr.Functions |
isSimSymbol | Recognize.SubExpr.Functions |
isSquare | Domain.LinearAlgebra.Matrix |
isStepN1 | Task.Matryoshka.Assess |
isStepN2a | Task.Matryoshka.Assess |
isStepN2b | Task.Matryoshka.Assess |
isStop | Recognize.SubExpr.Functions |
isStopSymbol | Recognize.SubExpr.Functions |
isSub | Recognize.SubExpr.Functions |
isSubExprOf | |
1 (Function) | Util.Expr |
2 (Function) | Recognize.SubExpr.Functions |
isSubSymbol | Recognize.SubExpr.Functions |
isTimesT | Domain.Math.Polynomial.BalanceUtils |
isUnknown | Recognize.Model.Result |
isUpperTriangular | Domain.LinearAlgebra.Matrix |
isVar | |
1 (Function) | Recognize.SubExpr.Functions |
2 (Function) | Recognize.Expr.Functions |
isVarSymbol | Recognize.SubExpr.Functions |
isWildcardSymbol | Recognize.Expr.Symbols |
joinBy | Domain.Math.Power.Utils |
Label | Recognize.Data.Attribute |
label | Bayes.Network |
label2state | Bayes.Network |
LabelE | Recognize.Data.Attribute |
labelSymbol | Recognize.SubExpr.Symbols |
lang | Service.Types |
Language | Recognize.Data.Solution |
language | Recognize.Data.Solution |
latestEvidence | Database.Data |
latestInsertRowID | Database.Data |
latestPartialModels | Database.Data |
latestRecord | Database.Data |
latestStudentModel | Database.Data |
latestStudentReport | Database.Data |
Layout | Bayes.SVG |
layout | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.TheatreRate |
3 (Function) | Task.Network.StudentModel |
4 (Function) | Task.Network.RectangleArea |
5 (Function) | Task.Network.Pattern |
6 (Function) | Task.Network.Matryoshka |
7 (Function) | Task.Network.MakingASquare |
8 (Function) | Task.Network.MagicTrick |
9 (Function) | Task.Network.CarRental |
10 (Function) | Task.Network.AreaOfATriangle |
11 (Function) | Task.Network.AreaAndExpression |
LayoutMode | Recognize.Data.StringLexer |
layoutMode | Recognize.Data.StringLexer |
lbl | Recognize.SubExpr.Symbols |
lblE | Recognize.SubExpr.Symbols |
lcmExpr | Domain.Math.Polynomial.LeastCommonMultiple |
lexer | Recognize.Data.MathStoryProblem |
LexerOutput | |
1 (Type/Class) | Recognize.Data.StringLexer |
2 (Data Constructor) | Recognize.Data.StringLexer |
lexerOutput | Recognize.Data.DiagnoseResult |
liftRule | Recognize.Strategy.Rules |
liftS | Domain.Math.Simplification |
liftS2 | Domain.Math.Simplification |
limitNesting | Bayes.StudentReport |
linbal | Domain.Math.Polynomial.BalanceUtils |
Linear | Recognize.SubExpr.SEParser |
linearEquationView | Domain.Math.Polynomial.Views |
linearExamples | Domain.Math.Polynomial.Examples |
linearGen | Domain.Math.Polynomial.Generators |
linearPolyView | Domain.Math.Polynomial.Views |
linearView | Domain.Math.Polynomial.Views |
linearViewWith | Domain.Math.Polynomial.Views |
LinearWithType | Recognize.SubExpr.SEParser |
listOfPowerFactors | Domain.Math.Polynomial.Views |
locNode | Database.HumanAssessment |
locStudent | Database.HumanAssessment |
locTask | Database.HumanAssessment |
logarithm | Domain.Math.Power.Rules |
logView | Domain.Math.Power.Views |
lt | Recognize.SubExpr.Symbols |
ltSymbol | Recognize.SubExpr.Symbols |
M | Recognize.Data.Math |
magicNatSymbol | Recognize.SubExpr.Symbols |
magicNumberSymbol | Recognize.SubExpr.Symbols |
magicTrick | Task.MagicTrick.Recognizer |
magicVarSymbol | Recognize.SubExpr.Symbols |
makeFactor | Bayes.Factor |
makeFAStep | Recognize.Data.Step, Recognize.Data.Diagnosis |
makeInvRule | Domain.Logic.Utils |
makeInvRuleWithUse | Domain.Logic.Utils |
makeListRule | Domain.Logic.Utils |
makeMath | Recognize.Data.Math |
makeMatrix | Domain.LinearAlgebra.Matrix |
makeNetwork | Bayes.Network |
makeNodeConstraint | Recognize.Model.Constraint |
makePage | Util.W3CSSHTML |
makeProbabilities | Bayes.Evidence |
makeSimpleRule | Domain.Logic.Utils |
makingASquare | Task.MakingASquare |
many' | Recognize.Parsing.Derived |
many1 | Recognize.Parsing.Derived |
many1' | Recognize.Parsing.Derived |
mapGerman | Recognize.Preprocessing |
mapNodes | Bayes.Network |
mapNodesM | Bayes.Network |
mapWithPos | Domain.LinearAlgebra.Matrix |
Match | |
1 (Type/Class) | Database.HumanAssessment |
2 (Data Constructor) | Database.HumanAssessment |
matchAbsence | Database.HumanAssessment |
MatchedBy | Recognize.Data.Attribute |
matchExpr | Recognize.SubExpr.Symbols |
matchings | Recognize.SubExpr.SEParser |
matchLin | Domain.Math.Polynomial.BalanceUtils |
matchPlusCon | Domain.Math.Polynomial.BalanceUtils |
matchPredicate | Recognize.SubExpr.SEParser |
matchRuleId | Recognize.Data.RuleId |
matchState | Database.HumanAssessment |
matchSymbol | Recognize.SubExpr.Symbols |
Math | Recognize.Data.Math |
mathListHtml | Recognize.Data.Math |
MathParseError | |
1 (Type/Class) | Recognize.Data.Math |
2 (Data Constructor) | Recognize.Data.Math |
mathParser | Recognize.Data.MathParserOutput |
MathParserOptions | Recognize.Data.MathParserOptions |
mathParserOptions | Recognize.Data.MathParserOptions |
MathParserOutput | |
1 (Type/Class) | Recognize.Data.MathParserOutput |
2 (Data Constructor) | Recognize.Data.MathParserOutput |
mathParserOutput | Recognize.Data.MathParserOutput |
MathStoryProblem | Recognize.Data.MathStoryProblem |
mathStoryProblem | Recognize.Data.MathStoryProblem |
Matrix | Domain.LinearAlgebra.Matrix |
matryoshka | Task.Matryoshka.Recognizer |
maybeToParse | Recognize.Parsing.Derived |
merge | Domain.Math.Polynomial.Rules |
mergeAlike | Domain.Math.Simplification |
mergeAlikeProduct | Domain.Math.Simplification |
mergeAlikeSum | Domain.Math.Simplification |
mergeConstants | Domain.Math.Power.Utils |
mergeConstantsWith | Domain.Math.Power.Utils |
mergeNums | Recognize.Strategy.Rules |
mergesD | Bayes.Factor |
mergeSteps | Recognize.Data.Step, Recognize.Data.Diagnosis |
mergeVars | Recognize.Strategy.Rules |
minFactorOrder | Bayes.EliminationOrdering |
minFactorVars | Bayes.EliminationOrdering |
minusNegateLeft | Domain.Math.Numeric.Rules |
minusNegateRight | Domain.Math.Numeric.Rules |
minusRule | Domain.Math.Equation.BalanceRules |
minusView | Domain.Math.Polynomial.BalanceUtils |
Misconception | Recognize.Data.Attribute |
mismatchState | Database.HumanAssessment |
mkNoisyAdder | Bayes.NodeTypes |
mkNoisyAdder2 | Bayes.NodeTypes |
mkNoisyOr | Bayes.NodeTypes |
mkSum | Domain.Math.Data.MultivariatePolynomial |
modify | Recognize.SubExpr.SEParser |
modifyAt | Util.List |
monomialPolyView | Domain.Math.Polynomial.Views |
moveToLeft | Domain.Math.Polynomial.Rules |
MParser | Recognize.Parsing.MathParser |
Mul | Recognize.Data.Op |
mul3C | Task.MagicTrick.Assess |
mulExponents | Domain.Math.Power.Rules |
multByConcatenation | Recognize.Data.MathParserOptions |
multiply | |
1 (Function) | Bayes.Factor |
2 (Function) | Domain.LinearAlgebra.Matrix |
multiplyOneDiv | Domain.Math.Polynomial.RationalRules |
MultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
multivariatePolynomialToMap | Domain.Math.Data.MultivariatePolynomial |
multivariatePolynomialView | Domain.Math.Data.MultivariatePolynomial |
multivariatePolynomialViewWith | Domain.Math.Data.MultivariatePolynomial |
mulZero | Domain.Math.Polynomial.Rules |
mWhen | Util.Monad |
myFractionTimes | Domain.Math.Power.Rules |
myIntegerView | Domain.Math.Power.Utils |
name | Bayes.Network |
namedWildcard | Recognize.Expr.Symbols |
namedWildcardSymbol | Recognize.Expr.Symbols |
naturalRules | Domain.Math.Power.Utils |
negate | Recognize.Model.Result |
negateBothSides | Domain.Math.Polynomial.Balance |
negateConstraint | Recognize.Model.Connectives |
negateMV | Domain.Math.Data.MultivariatePolynomial |
negateZero | Domain.Math.Numeric.Rules |
negView | Domain.Math.Polynomial.BalanceUtils |
nestRight | Recognize.Data.Op |
Network | Bayes.Network |
network | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.TheatreRate |
3 (Function) | Task.Network.StudentModel |
4 (Function) | Task.Network.RectangleArea |
5 (Function) | Task.Network.Pattern |
6 (Function) | Task.Network.Matryoshka |
7 (Function) | Task.Network.MakingASquare |
8 (Function) | Task.Network.MagicTrick |
9 (Function) | Task.Network.CarRental |
10 (Function) | Task.Network.AreaOfATriangle |
11 (Function) | Task.Network.AreaAndExpression |
networkFile | Recognize.Data.MathStoryProblem |
networkInterface | Bayes.InterfaceWriter |
networkToHTML | Bayes.SVG |
networkToSVG | Bayes.SVG |
newDiagnosis | Recognize.Data.Diagnosis |
newEvidence | Bayes.Evidence |
newMagicNat | Recognize.SubExpr.Symbols |
newMagicNumber | Recognize.SubExpr.Symbols |
newMagicVar | Recognize.SubExpr.Symbols |
newton | Domain.Math.Approximation |
newVar | Recognize.Model.EvidenceBuilder |
NExpr | Recognize.Data.Attribute |
nextVariable | Bayes.EliminationOrdering |
nf | Recognize.Expr.Normalform |
nf4 | Recognize.Expr.Normalform |
nfCom | Recognize.Expr.Normalform |
nfComAssoc | Recognize.Expr.Normalform |
niceFactors | Domain.Math.Polynomial.Rules |
niceFactorsNew | Domain.Math.Polynomial.Rules |
NL | Recognize.Data.Solution |
nnfStep | Domain.Logic.Strategies |
NoApproach | Recognize.Data.Approach |
noCommonFactor | Domain.Math.Polynomial.LeastCommonMultiple |
Node | |
1 (Type/Class) | Bayes.Network |
2 (Data Constructor) | Bayes.Network |
node | Bayes.Network |
NodeConstraint | |
1 (Type/Class) | Recognize.Model.Constraint |
2 (Data Constructor) | Recognize.Model.Constraint |
NodeID | Database.Data |
nodeId | Bayes.Network |
nodeIds | Bayes.Network |
nodeIsSet | Bayes.Evidence |
nodeNotSet | Bayes.Evidence |
nodes | Bayes.Network |
nodeSetTo | Bayes.Evidence |
node_ | Bayes.Network |
noDivisionConstant | Domain.Math.Polynomial.Rules |
NoisyAdder | Bayes.Network |
NoisyMax | Bayes.Network |
noLinFormula | Domain.Math.Polynomial.Rules |
nonEmpty | Recognize.Parsing.Derived |
NonMatchingParentheses | Recognize.Data.Attribute |
nonZero | |
1 (Function) | Domain.Math.Numeric.Generators |
2 (Function) | Domain.LinearAlgebra.Matrix |
noPars | Task.MagicTrick.Recognizer |
normalform | Recognize.Expr.Symbols |
normalformSymbol | Recognize.Expr.Symbols |
normalize | |
1 (Function) | Bayes.Factor |
2 (Function) | Util.String |
3 (Function) | Recognize.Strategy.Applications |
4 (Function) | Main.Diagnose |
Normalized | Recognize.Data.Attribute |
normalizeExercise | Recognize.Strategy.Exercises |
normalizeIfNF | Recognize.Expr.Functions |
normalizeLogicA | Domain.Logic.Generator |
normalizeStrategy | Recognize.Strategy.Strategies |
noSim | Recognize.SubExpr.Symbols |
noSimSymbol | Recognize.SubExpr.Symbols |
noVirtuals | Bayes.Evidence |
nullity | Domain.LinearAlgebra.Matrix |
NumberRange | Util.NumberRange |
Numerical | Recognize.Data.Approach |
numGenerator | Domain.Math.Numeric.Generators |
observation | Database.HumanAssessment |
oneF | Domain.Math.Data.MultivariatePolynomial |
onePower | Domain.Math.Power.Rules |
oneVar | Domain.Math.Polynomial.Rules |
Op | Recognize.Data.Op |
OperatorMixedUp | Recognize.Data.Attribute |
optGrow | Recognize.SubExpr.SEParser |
option | Recognize.Parsing.Parse |
optionNegate | Recognize.Strategy.Views |
optIterate | Recognize.SubExpr.SEParser |
optSimplify | Recognize.SubExpr.SEParser |
optSkipOnce | Recognize.SubExpr.SEParser |
optTraverse | Recognize.SubExpr.SEParser |
orderBy | Util.List |
originalInput | Recognize.Data.DiagnoseResult |
orRules | Domain.Logic.Strategies |
orSymbol | Recognize.SubExpr.Symbols |
orView | |
1 (Function) | Domain.Logic.Utils |
2 (Function) | Domain.Logic.Views |
oSkipExpressions | Task.MagicTrick.Recognizer |
Other | |
1 (Data Constructor) | Recognize.Data.Approach |
2 (Data Constructor) | Recognize.Data.Attribute |
oTryManyBuggyPars | Task.MagicTrick.Recognizer |
outCategories | Main.Diagnose |
outDiagnose | Main.Diagnose |
pAnnounce | Task.MagicTrick.Recognizer |
pAnyExpr | Recognize.Parsing.Derived |
pAnyOf | Recognize.Parsing.Derived |
pAnywhere | Recognize.Parsing.Derived |
parenthesisMismatch | Recognize.Data.Diagnosis |
parentIds | Bayes.Network |
parents | Bayes.Network |
Parse | Recognize.Parsing.Parse |
parseColumns | Recognize.Parsing.MathLexer |
parseConsequence | Domain.Logic.Parser |
ParseLog | Recognize.Parsing.Parse |
parseLogic | Domain.Logic.Parser |
parseLogicPars | Domain.Logic.Parser |
parseLogicProof | Domain.Logic.Parser |
parseLogicProofs | Domain.Logic.Parser |
parseLogicUnicodePars | Domain.Logic.Parser |
parseMath | Recognize.Parsing.MathParser |
Parser | Recognize.Parsing.Parser |
parser | Recognize.Data.MathStoryProblem |
parserOutput | Recognize.Data.DiagnoseResult |
ParserT | Recognize.Parsing.Parser |
parseSimple | Recognize.Parsing.MathLexer |
parseSimple' | Recognize.Parsing.MathParser |
parseStatement | Domain.Logic.Parser |
PartialMatch | Recognize.Data.Attribute |
pAttempts | Task.MagicTrick.Recognizer |
pAttempts1 | Task.MagicTrick.Recognizer |
pattern | Task.Pattern.Recognizer |
payload | Recognize.Data.Diagnosis |
pBuggyStep | Task.MagicTrick.Recognizer |
pCompare | Recognize.SubExpr.Compare |
pCompareByNormalize | Recognize.SubExpr.Compare |
pCompareBySimplify | Recognize.SubExpr.Compare |
pConclude | Task.MagicTrick.Recognizer |
pDiagnosis | Task.MagicTrick.Recognizer |
peek | Recognize.Parsing.Derived |
peek2 | Recognize.Parsing.Derived |
peekEq | Recognize.Parsing.Derived |
peekExpr | Recognize.Parsing.Derived |
pEq | Recognize.Parsing.Derived |
pEqCom | Recognize.Parsing.Derived |
pEqWith | Task.MagicTrick.Recognizer |
pEqWith2 | Task.MagicTrick.Recognizer |
pEqWithL | Task.MagicTrick.Recognizer |
perc | Main.Diagnose |
percentage | |
1 (Function) | Util.String |
2 (Function) | Util.Table |
percPar | Main.Diagnose |
Perimeter | Recognize.Data.Attribute |
pExercise | Recognize.Strategy.Recognizer |
pExplicitSimplifyEq | Task.MagicTrick.Recognizer |
pExplicitSimplifyExpr | Task.MagicTrick.Recognizer |
pExpr | Recognize.Parsing.Derived |
pExprCom | Recognize.Parsing.Derived |
pExprWith | Recognize.Parsing.Derived |
pFixEqCom | Task.MagicTrick.Recognizer |
pFixExprCom | Task.MagicTrick.Recognizer |
pFoldAlt | Recognize.Parsing.Derived |
pIf | Task.MagicTrick.Recognizer |
PilotID | Database.Data |
pInOrder | Recognize.Parsing.Derived |
pInOrderAll | Recognize.Parsing.Derived |
pivot | Domain.LinearAlgebra.Matrix |
plainNatView | Domain.Math.Power.Utils, Domain.Math.Power.Views |
plainRationalView | Domain.Math.Power.Utils, Domain.Math.Power.Views |
pLog | Recognize.Parsing.Parse |
plus | Domain.Math.Data.MultivariatePolynomial |
plusNegateLeft | Domain.Math.Numeric.Rules |
plusNegateRight | Domain.Math.Numeric.Rules |
plusRule | Domain.Math.Equation.BalanceRules |
pMagicExpr | Task.MagicTrick.Recognizer |
pMatchEq | Task.MagicTrick.Recognizer |
pMatchExpr | Task.MagicTrick.Recognizer |
pMatchSubSteps | Recognize.SubExpr.Recognizer |
pNamedStep | Recognize.Parsing.Interpretation |
pNextStepBuggyPars | Task.MagicTrick.Recognizer |
Point | Bayes.SVG |
pointX | Bayes.SVG |
pointY | Bayes.SVG |
polynomialDegreeGen | Domain.Math.Polynomial.Generators |
polynomialGen | Domain.Math.Polynomial.Generators |
polyNormalForm | Domain.Math.Polynomial.Views |
polyRelaxedForm | Domain.Math.Polynomial.Views |
polyView | Domain.Math.Polynomial.Views |
polyViewWith | Domain.Math.Polynomial.Views |
Power | Recognize.Data.RuleId |
power2root | Domain.Math.Power.Rules |
powerFactorView | |
1 (Function) | Domain.Math.Power.OldViews |
2 (Function) | Domain.Math.Power.Views |
powerFactorViewForWith | Domain.Math.Power.OldViews |
powerFactorViewWith | Domain.Math.Power.OldViews |
powerOne | Domain.Math.Power.Rules |
powerProductView | Domain.Math.Polynomial.LeastCommonMultiple |
powerView | Domain.Math.Power.Views |
powerViewFor | Domain.Math.Power.Views |
powerViewWith | Domain.Math.Power.Views |
powerZero | Domain.Math.Power.Rules |
ppExpr | Recognize.Data.Math |
ppLogicPars | Domain.Logic.Parser |
ppLogicUnicodePars | Domain.Logic.Parser |
precision | |
1 (Function) | Domain.Math.Approximation |
2 (Function) | Recognize.SubExpr.SEParser |
predicateCombined | Domain.Math.Equation.CoverUpRules |
predicateCovered | Domain.Math.Equation.CoverUpRules |
prepareSplitSquare | Domain.Math.Polynomial.Rules |
pRepeat | Recognize.Parsing.Derived |
pReplicate | Recognize.Parsing.Derived |
preProcess | Recognize.Preprocessing |
prettyMap | Util.Pretty |
prettyMatches | Database.HumanAssessment |
pRewrite | Recognize.Parsing.Derived |
printCache | Util.Cache |
printMath | Recognize.Data.Math |
Prior | |
1 (Type/Class) | Database.Priors |
2 (Data Constructor) | Database.Priors |
Priors | |
1 (Type/Class) | Database.Priors |
2 (Data Constructor) | Database.Priors |
Probabilities | Bayes.Evidence |
probabilitiesFor | Bayes.Evidence |
Probability | Bayes.Probability |
probHigh | Task.MagicTrick.Recognizer |
problemId | Recognize.Data.MathStoryProblem |
probLow | Task.MagicTrick.Recognizer |
probMediumLow | Task.MagicTrick.Recognizer |
processInputs | Recognize.Data.MathStoryProblem |
Product | Domain.Math.Data.MultivariatePolynomial |
propositionalId | Domain.Logic.Utils |
pruneNetwork | Bayes.Inference |
pSkipUntil | Recognize.Parsing.Derived |
pSolveLinear | Recognize.Strategy.Applications |
pSomewhere | Recognize.Parsing.Derived |
pStdDiagnosis | Task.MagicTrick.Recognizer |
pStep | |
1 (Function) | Recognize.Parsing.Interpretation |
2 (Function) | Task.MagicTrick.Recognizer |
pStepEq | Recognize.Parsing.Interpretation |
pStepEquation | Task.MagicTrick.Recognizer |
pStepErr | Task.MagicTrick.Recognizer |
pStepError | Task.MagicTrick.Recognizer |
pStepExpr | Task.MagicTrick.Recognizer |
pStepForget | Task.MagicTrick.Recognizer |
pStepIneq | Recognize.Parsing.Interpretation |
pStepOperators | Task.MagicTrick.Recognizer |
pStepsFor | Task.MagicTrick.Recognizer |
pStepSimplify | Task.MagicTrick.Recognizer |
pStepsPhase1 | Task.MagicTrick.Recognizer |
pStepsPhase2 | Task.MagicTrick.Recognizer |
pStepsPhase3 | Task.MagicTrick.Recognizer |
pStepsPhase4 | Task.MagicTrick.Recognizer |
pStepStrongIneq' | Recognize.Parsing.Interpretation |
pSubstituteVars | Recognize.SubExpr.Compare |
pt | Bayes.SVG |
pTask | Task.MagicTrick.Recognizer |
pTaskErr | Task.MagicTrick.Recognizer |
pTaskForget | Task.MagicTrick.Recognizer |
pTaskSimplify | Task.MagicTrick.Recognizer |
pushNegOut | Domain.Math.Power.Rules |
pushNot | Domain.Logic.Views |
pushNotWith | Domain.Logic.Views |
put | Recognize.SubExpr.SEParser |
putAttributes | Recognize.Model.EvidenceBuilder |
putVariables | Recognize.Model.EvidenceBuilder |
pVars | Task.MagicTrick.Recognizer |
quadraticEquationsView | Domain.Math.Polynomial.Views |
quadraticEquationView | Domain.Math.Polynomial.Views |
quadraticExamples | Domain.Math.Polynomial.Examples |
quadraticGen | Domain.Math.Polynomial.Generators |
quadraticPolyView | Domain.Math.Polynomial.Views |
quadraticRuleOrder | Domain.Math.Polynomial.Rules |
quadraticView | Domain.Math.Polynomial.Views |
quadraticViewWith | Domain.Math.Polynomial.Views |
Query | Bayes.Inference |
quickQueryMap | Database.Data |
r | Task.Network.StudentModel |
r1 | Task.Network.StudentModel |
r11 | Task.Network.StudentModel |
r11_T02 | Task.Network.CarRental |
r11_T05 | Task.Network.MagicTrick |
r11_T10 | Task.Network.Matryoshka |
r11_T10_P1 | Task.Network.Matryoshka |
r11_T10_P2 | Task.Network.Matryoshka |
r12 | Task.Network.StudentModel |
r121 | Task.Network.StudentModel |
r1211 | Task.Network.StudentModel |
r1211_T02 | Task.Network.CarRental |
r1211_T03 | Task.Network.Pattern |
r1211_T05 | Task.Network.MagicTrick |
r1211_T06 | Task.Network.TheatreRate |
r1211_T10 | Task.Network.Matryoshka |
r1212 | Task.Network.StudentModel |
r1212_T02 | Task.Network.RectangleArea |
r1212_T04 | Task.Network.MakingASquare |
r1212_T08 | Task.Network.AreaOfATriangle |
r1212_T09 | Task.Network.AreaAndExpression |
r1213 | Task.Network.StudentModel |
r1213_T02 | Task.Network.CarRental |
r1213_T03 | Task.Network.Pattern |
r1213_T06 | Task.Network.TheatreRate |
r1213_T07 | Task.Network.VPattern |
r1213_T08 | Task.Network.AreaOfATriangle |
r1214 | Task.Network.StudentModel |
r1214_T02 | Task.Network.RectangleArea |
r1214_T04 | Task.Network.MakingASquare |
r1215 | Task.Network.StudentModel |
r1215_T10 | Task.Network.Matryoshka |
r121_T05 | Task.Network.MagicTrick |
r121_T06 | Task.Network.TheatreRate |
r12_T02 | |
1 (Function) | Task.Network.RectangleArea |
2 (Function) | Task.Network.CarRental |
r12_T03 | Task.Network.Pattern |
r12_T06 | Task.Network.TheatreRate |
r12_T08 | Task.Network.AreaOfATriangle |
r13 | Task.Network.StudentModel |
r13_T02 | Task.Network.CarRental |
r13_T03 | Task.Network.Pattern |
r13_T06 | Task.Network.TheatreRate |
r3 | Task.Network.StudentModel |
r31 | Task.Network.StudentModel |
r31_T02 | Task.Network.CarRental |
r31_T03 | Task.Network.Pattern |
r31_T05 | Task.Network.MagicTrick |
r31_T06 | Task.Network.TheatreRate |
r31_T10 | Task.Network.Matryoshka |
r31_T10_P1 | Task.Network.Matryoshka |
r31_T10_P2 | Task.Network.Matryoshka |
r32 | Task.Network.StudentModel |
r321 | Task.Network.StudentModel |
r321_T08 | Task.Network.AreaOfATriangle |
r321_T10 | Task.Network.Matryoshka |
r322 | Task.Network.StudentModel |
r3221 | Task.Network.StudentModel |
r3221_T02 | Task.Network.RectangleArea |
r3221_T04 | Task.Network.MakingASquare |
r3221_T05 | Task.Network.MagicTrick |
r3221_T08 | |
1 (Function) | Task.Network.VPattern |
2 (Function) | Task.Network.AreaOfATriangle |
r3222 | Task.Network.StudentModel |
r3222_T08 | Task.Network.AreaOfATriangle |
r3223 | Task.Network.StudentModel |
r3223_T04 | Task.Network.MakingASquare |
r3223_T05 | Task.Network.MagicTrick |
r323 | Task.Network.StudentModel |
r323_T02 | Task.Network.CarRental |
r323_T03 | Task.Network.Pattern |
r323_T06 | Task.Network.TheatreRate |
r323_T08 | Task.Network.AreaOfATriangle |
r324 | Task.Network.StudentModel |
r324_T02 | Task.Network.CarRental |
r324_T03 | Task.Network.Pattern |
r324_T06 | Task.Network.TheatreRate |
r324_T08 | Task.Network.AreaOfATriangle |
range | Util.NumberRange |
rank | Domain.LinearAlgebra.Matrix |
ratioExprGen | Domain.Math.Numeric.Generators |
ratioExprGenNonZero | Domain.Math.Numeric.Generators |
ratioGen | Domain.Math.Numeric.Generators |
rationalGenerator | Domain.Math.Numeric.Generators |
rationalRelaxedForm | Recognize.Strategy.Views |
rationalRules | Domain.Math.Power.Utils |
readEvidence | Database.HumanAssessment |
readFileCSV | Main.ParserCSV |
readNetwork | Bayes.NetworkReader |
reciprocal | Domain.Math.Power.Rules |
reciprocalFrac | Domain.Math.Power.Rules |
reciprocalInv | Domain.Math.Power.Rules |
reciprocalPower | Domain.Math.Power.Rules |
reciprocalVar | Domain.Math.Power.Rules |
recognizer | Recognize.Data.MathStoryProblem |
recognizerExercise | Recognize.Strategy.Exercises |
recognizerStrategy | Recognize.Strategy.Strategies |
recordN | Database.Data |
records2table | Database.Data |
Recovery | Recognize.Data.Attribute |
Rectangle | Recognize.Data.Attribute |
rectangleArea | Task.RectangleArea |
Recursive | Recognize.Data.Approach |
reduce | Domain.LinearAlgebra.Matrix |
relationSolvedForm | Domain.Math.Equation.Views |
relationsSolvedForm | Domain.Math.Equation.Views |
relationView | Domain.Math.Power.Utils |
relative | Domain.Math.Approximation |
relEqualityView | Recognize.Strategy.Views |
removeDivision | |
1 (Function) | Domain.Math.Polynomial.Rules |
2 (Function) | Domain.Math.Polynomial.Balance |
removeTimes | Recognize.Strategy.Rules |
renameEvidence | Bayes.Evidence |
renameNodes | Bayes.Network |
replace | Util.String |
replaceLeft | Recognize.Expr.Functions |
replaceRight | Recognize.Expr.Functions |
replaceXByMultiplication | Recognize.Data.StringLexerOptions |
reportDatabase | Main.Report |
requestsTable | Database.Data |
resetAfter | Recognize.SubExpr.SEParser |
resetSEState | Recognize.SubExpr.SEParser |
restoreWildcards | Util.Expr |
restrict | Main.Diagnose |
Result | Recognize.Model.Result |
result | Recognize.Data.Diagnosis |
resultIsSimplified | Recognize.Data.Diagnosis |
resultToBool | Recognize.Model.Result |
returnOnJustM | Util.List |
rewriteSqrt | Recognize.Expr.Normalform |
root2power | Domain.Math.Power.Rules |
rootView | Domain.Math.Power.Views |
roundDouble | Recognize.Expr.Normalform |
RoundingError | Recognize.Data.Attribute |
roundNumber | Recognize.Expr.Functions |
Row | |
1 (Type/Class) | Domain.LinearAlgebra.Matrix |
2 (Type/Class) | Main.ParserCSV |
3 (Data Constructor) | Recognize.Data.StringLexer |
row | Domain.LinearAlgebra.Matrix |
rowHeaders | Util.TableData |
rows | Domain.LinearAlgebra.Matrix |
rowsHalf | Recognize.Data.DiagnoseResult |
ruleAbsorpAnd | Domain.Logic.Rules |
ruleAbsorpOr | Domain.Logic.Rules |
ruleApproximate | Domain.Math.Polynomial.Rules |
ruleAssocAnd | Domain.Logic.Rules |
ruleAssocOr | Domain.Logic.Rules |
ruleCommAnd | Domain.Logic.Rules |
ruleCommOr | Domain.Logic.Rules |
ruleComplAnd | Domain.Logic.Rules |
ruleComplOr | Domain.Logic.Rules |
ruleDefEquiv | Domain.Logic.Rules |
ruleDefImpl | Domain.Logic.Rules |
ruleDeMorganAnd | Domain.Logic.Rules |
ruleDeMorganOr | Domain.Logic.Rules |
ruleDistrAnd | Domain.Logic.Rules |
ruleDistrOr | Domain.Logic.Rules |
ruleDoubleNeg | Domain.Logic.Rules |
ruleFalseAnd | Domain.Logic.Rules |
ruleFalseOr | Domain.Logic.Rules |
RuleId | Recognize.Data.RuleId |
ruleIdempAnd | Domain.Logic.Rules |
ruleIdempOr | Domain.Logic.Rules |
ruleNormalizeMixedFraction | Domain.Math.Polynomial.Rules |
ruleNormalizePolynomial | Domain.Math.Polynomial.Rules |
ruleNormalizeRational | Domain.Math.Polynomial.Rules |
ruleNotFalse | Domain.Logic.Rules |
ruleNotTrue | Domain.Logic.Rules |
ruleTrueAnd | Domain.Logic.Rules |
ruleTrueOr | Domain.Logic.Rules |
runDomainReasoner | Service.AdviseMe |
runParser | Recognize.Parsing.Parser |
runParserT | Recognize.Parsing.Parser |
runService | Service.AdviseMe |
safeHead | Util.List |
safeLast | Util.List |
safePeek | Recognize.Parsing.Parse |
safeSingleton | Util.List |
sameConFactor | Domain.Math.Polynomial.Rules |
sameDividend | Domain.Math.Polynomial.RationalRules |
sameDivisor | Domain.Math.Polynomial.RationalRules |
sameFactor | Domain.Math.Polynomial.Rules |
satisfy | Recognize.Parsing.Parse |
satisfyEq | Recognize.Parsing.Derived |
satisfyWith | Recognize.Parsing.Parse |
scale | Domain.LinearAlgebra.Matrix |
scaleRow | Domain.LinearAlgebra.Matrix |
scaleToOne | Domain.Math.Polynomial.Balance |
score | Database.HumanAssessment |
selections | Util.List |
SemEq | Domain.Math.Power.Utils |
seParse | Recognize.SubExpr.SEParser |
SEParser | Recognize.SubExpr.SEParser |
sequencer | Service.Sequencer |
sequencerService | Service.Sequencer |
seRecognizer | Recognize.Recognizer |
SEState | |
1 (Type/Class) | Recognize.SubExpr.SEParser |
2 (Data Constructor) | Recognize.SubExpr.SEParser |
set | Bayes.Evidence |
setEntries | Domain.LinearAlgebra.Matrix |
setEntry | Domain.LinearAlgebra.Matrix |
setId | Bayes.Evidence |
setN | Bayes.Evidence |
setValueOf | Recognize.Model.EvidenceBuilder |
showMathList | Recognize.Data.Math |
sim | Recognize.SubExpr.Symbols |
simpleAddExponents | Domain.Math.Power.Rules |
simpleOrder | Bayes.EliminationOrdering |
simplerFraction | Domain.Math.Numeric.Rules |
simplerLinearFactor | Domain.Math.Polynomial.Rules |
simplerPolynomial | Domain.Math.Polynomial.Rules |
simplerSquareRootMulti | Domain.Math.Polynomial.Rules |
Simplified | Domain.Math.Simplification |
simplified | Domain.Math.Simplification |
Simplify | Domain.Math.Simplification |
simplify | |
1 (Function) | Domain.Logic.Views |
2 (Function) | Domain.Math.Simplification |
3 (Function) | Recognize.Strategy.Applications |
SimplifyConfig | |
1 (Type/Class) | Domain.Math.Simplification |
2 (Data Constructor) | Domain.Math.Simplification |
simplifyConfig | Domain.Math.Simplification |
simplifyExercise | Recognize.Strategy.Exercises |
simplifyPower | Domain.Math.Power.Rules |
simplifyRule | Domain.Math.Simplification |
simplifyStep | Domain.Logic.Strategies |
simplifyStrategy | Recognize.Strategy.Strategies |
simplifyWith | Domain.Math.Simplification |
simSymbol | Recognize.SubExpr.Symbols |
simulate | Bayes.Inference |
singleNetwork | Recognize.Data.MathStoryProblem |
size | |
1 (Function) | Bayes.Factor |
2 (Function) | Bayes.Network |
sizeId | Bayes.Network |
skillID | Bayes.StudentReport |
skillText | Bayes.StudentReport |
skillValue | Bayes.StudentReport |
skip | Recognize.Parsing.Derived |
Sloppiness | Recognize.Data.Attribute |
smallStep | Recognize.Data.Step |
smart | Domain.Math.CleanUp |
smartRule | Domain.Math.Power.Utils |
Solution | |
1 (Type/Class) | Recognize.Data.Solution |
2 (Data Constructor) | Recognize.Data.Solution |
solution | Service.Types |
somewhereAnd | Domain.Logic.Utils |
somewhereOr | Domain.Logic.Utils |
sortEquation | Domain.Math.Power.Utils |
sortExpr | Domain.Math.Power.Utils |
sortOrList | Domain.Math.Power.Utils |
Source | Recognize.Data.Solution |
source | Service.Types |
specialDeMorganNot | Domain.Logic.Strategies |
specialDistrNot | Domain.Logic.Strategies |
specialGroupLiterals | Domain.Logic.Strategies |
split | |
1 (Function) | Domain.Math.Power.Utils |
2 (Function) | Util.String |
splitOn | Util.String |
splitOn' | Util.String |
splits | Task.MagicTrick.Recognizer |
SqlRecord | Database.Data |
SqlTable | |
1 (Type/Class) | Database.Data |
2 (Data Constructor) | Database.Data |
Square | Recognize.Data.Attribute |
squareBothSides | Domain.Math.Polynomial.Rules |
squared | Recognize.Parsing.Interpretation |
squareRootView | Domain.Math.SquareRoot.Views |
squareRootViewWith | Domain.Math.SquareRoot.Views |
state2label | Bayes.Network |
states | Bayes.Network |
staticOrder | Bayes.EliminationOrdering |
Step | |
1 (Type/Class) | Recognize.Data.Step, Recognize.Data.Diagnosis |
2 (Data Constructor) | Recognize.Data.Step |
stepBuilder | Task.Matryoshka.Assess |
steps | Recognize.Data.Diagnosis |
stepsA1Builder | |
1 (Function) | Task.VPattern.Assess |
2 (Function) | Task.MagicTrick.Assess |
stepsA2Builder | |
1 (Function) | Task.VPattern.Assess |
2 (Function) | Task.MagicTrick.Assess |
stepsA3Builder | Task.VPattern.Assess |
stepsA4Builder | Task.VPattern.Assess |
stepsABuilder | Task.TheatreRate.Assess |
stepsAG1Builder | Task.Pattern.Assess |
stepsAG2Builder | Task.Pattern.Assess |
stepsAGBuilder | |
1 (Function) | Task.Pattern.Assess |
2 (Function) | Task.Matryoshka.Assess |
stepsN1Builder | |
1 (Function) | Task.Pattern.Assess |
2 (Function) | Task.Matryoshka.Assess |
3 (Function) | Task.MagicTrick.Assess |
stepsN2Builder | |
1 (Function) | Task.Pattern.Assess |
2 (Function) | Task.Matryoshka.Assess |
3 (Function) | Task.MagicTrick.Assess |
stepsNBuilder | Task.TheatreRate.Assess |
stepsToHTML | Recognize.Data.Step |
stepToHTML | Recognize.Data.Step |
stop | Recognize.SubExpr.Symbols |
stopSymbol | Recognize.SubExpr.Symbols |
storeEvidenceMaybe | Recognize.Model.EvidenceBuilder |
strictPowerView | Domain.Math.Power.Views |
strictRootView | Domain.Math.Power.Views |
stringLexer | Recognize.Data.StringLexer |
StringLexerOptions | Recognize.Data.StringLexerOptions |
stringLexerOptions | Recognize.Data.StringLexerOptions |
stringLexerOutput | Recognize.Data.StringLexer |
stringNode | Recognize.Model.Assess |
strToLower | Util.String |
strToUpper | Util.String |
StudentID | Database.Data |
studentID | Bayes.StudentReport |
StudentModel | Database.Data |
studentRecords | Database.Data |
StudentReport | |
1 (Type/Class) | Bayes.StudentReport |
2 (Data Constructor) | Bayes.StudentReport |
studentsTable | Database.Data |
Sub | Recognize.Data.Op |
sub | Recognize.SubExpr.Symbols |
sub4C | Task.MagicTrick.Assess |
subExponents | Domain.Math.Power.Rules |
subExprsCombs | Recognize.SubExpr.Functions |
subMatched | Recognize.SubExpr.Functions |
subskills | Bayes.StudentReport |
substBackVar | Domain.Math.Polynomial.Rules |
substitute | |
1 (Function) | Util.Expr |
2 (Function) | Recognize.Data.Op |
substituteAllIf | Recognize.SubExpr.Functions |
substOp | Recognize.Data.Op |
subSymbol | Recognize.SubExpr.Symbols |
subtract | Domain.Math.Data.MultivariatePolynomial |
subXC | Task.MagicTrick.Assess |
succeed | Recognize.Parsing.Derived |
succeedIf | Recognize.Parsing.Derived |
Success | Recognize.Model.Result |
success | Recognize.Model.Connectives |
Sum | Domain.Math.Data.MultivariatePolynomial |
sum' | Recognize.Parsing.Interpretation |
sum'' | Recognize.Parsing.Interpretation |
summarise | Database.HumanAssessment |
summariseTasks | Database.HumanAssessment |
sumout | Bayes.Factor |
sumouts | Bayes.Factor |
sumView | Recognize.Strategy.Views |
swap | Domain.Math.Power.Utils |
switchRows | Domain.LinearAlgebra.Matrix |
Table | |
1 (Type/Class) | Util.Table |
2 (Type/Class) | Util.TableData |
3 (Data Constructor) | Util.TableData |
tableExists | Database.Data |
tableList | Util.Table |
tableName | Database.Data |
Tables | Util.Table |
tables | Util.Table |
takeRoot | Domain.Math.Power.Utils |
Tally | |
1 (Type/Class) | Database.HumanAssessment |
2 (Data Constructor) | Database.HumanAssessment |
tally | Database.HumanAssessment |
tally' | Database.HumanAssessment |
Task | |
1 (Type/Class) | Recognize.Data.MathStoryProblem |
2 (Data Constructor) | Recognize.Data.MathStoryProblem |
task | Task.MagicTrick.Recognizer |
taskConcepts | Bayes.Script |
taskExpand | Task.MagicTrick.Recognizer |
taskForget | Task.MagicTrick.Recognizer |
TaskID | Database.Data |
taskIfZero | Task.MagicTrick.Recognizer |
taskNetwork | Main.Tasks |
taskRecords | Database.Data |
tasks | Main.Tasks |
tasksDone | Database.Data |
tAttr | Service.Types |
td | Util.W3CSSHTML |
tDiagnosis | Service.Types |
termRef | Domain.Math.Polynomial.BalanceUtils |
testLCM | Domain.Math.Polynomial.LeastCommonMultiple |
tGroupId | Service.Types |
th | Util.W3CSSHTML |
theatreRate | Task.TheatreRate.Recognizer |
timed | Main.Diagnose |
Timeout | Recognize.Data.DiagnoseError |
Times | Recognize.Data.RuleId |
times | Domain.Math.Data.MultivariatePolynomial |
times2 | Domain.Math.Data.MultivariatePolynomial |
times3 | Domain.Math.Data.MultivariatePolynomial |
timesF | Domain.Math.Data.MultivariatePolynomial |
timesNegateLeft | Domain.Math.Numeric.Rules |
timesNegateRight | Domain.Math.Numeric.Rules |
timesRule | Domain.Math.Equation.BalanceRules |
tInput | Service.Types |
tInputId | Service.Types |
tLanguage | Service.Types |
ToAttribute | Recognize.Strategy.Derivation |
toDefinition | Recognize.Data.Definition |
toDouble | Bayes.Probability |
toEvidence | Bayes.Inference |
toMaybe | Domain.Math.Power.Utils |
toMultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
toNetwork | Bayes.Inference |
toReport | Bayes.StudentReport |
toStep | Recognize.Parsing.Interpretation |
toTable | Util.TableData |
toTableFromCols | Util.TableData |
toTableFromRows | Util.TableData |
tr | Util.W3CSSHTML |
Translation | |
1 (Type/Class) | Bayes.StudentReport |
2 (Data Constructor) | Bayes.StudentReport |
translationDescription | Bayes.StudentReport |
translationExample | Bayes.StudentReport |
translationLabel | Bayes.StudentReport |
Triangle | Recognize.Data.Attribute |
trim | |
1 (Function) | Recognize.Parsing.MathLexer |
2 (Function) | Util.String |
trimFor | Bayes.Inference |
trinomialPolyView | Domain.Math.Polynomial.Views |
tSolution | Service.Types |
tSource | Service.Types |
tStudentReport | Service.Types |
tStudentReports | Service.Types |
turnIntoFraction | Domain.Math.Polynomial.RationalRules |
tUserId | Service.Types |
tUserIdTag | Service.Types |
tUserRequest | Service.Types |
twoNonAdjacentHoles | Domain.Math.Power.Utils |
unchain | Recognize.Expr.Functions |
unchainAll | Recognize.Expr.Functions |
underSubst | Recognize.SubExpr.Functions |
UnequalRelations | Recognize.Data.Attribute |
unescape | Util.XML |
unescapeAttr | Util.XML |
unitPowerView | Domain.Math.Power.Views |
unitPowerViewVar | Domain.Math.Power.Views |
Unknown | |
1 (Data Constructor) | Recognize.Data.DiagnoseError |
2 (Data Constructor) | Recognize.Model.Result |
unknown | Recognize.Model.Connectives |
unsafeDivide | Domain.Math.Data.MultivariatePolynomial |
updateVar | Recognize.Model.EvidenceBuilder |
useColumns | Recognize.Parsing.MathLexer |
usedVariables | Recognize.SubExpr.SEParser |
UserId | Recognize.Data.Solution |
userId | Recognize.Data.Solution |
UserRequest | |
1 (Type/Class) | Service.Types |
2 (Data Constructor) | Service.Types |
values | Bayes.Factor |
Var | Domain.Math.Data.MultivariatePolynomial |
var | |
1 (Function) | Recognize.SubExpr.Symbols |
2 (Function) | Domain.Math.Data.MultivariatePolynomial |
varF | Domain.Math.Data.MultivariatePolynomial |
variableWhitelist | Recognize.Data.StringLexerOptions |
varLeft | Domain.Math.Polynomial.Balance |
varLeftMinus | Domain.Math.Polynomial.Balance |
varLeftPlus | Domain.Math.Polynomial.Balance |
varRightMinus | Domain.Math.Polynomial.Balance |
varRightPlus | Domain.Math.Polynomial.Balance |
vars | |
1 (Function) | Bayes.Factor |
2 (Function) | Recognize.Expr.Functions |
varSet | Bayes.Factor |
varSymbol | Recognize.SubExpr.Symbols |
varToLeft | Domain.Math.Polynomial.Rules |
Virtual | Bayes.Evidence |
virtual | Bayes.Evidence |
virtualFactor | Bayes.NodeTypes |
virtualId | Bayes.Evidence |
Volume | Recognize.Data.Attribute |
vPattern | Task.VPattern.Recognizer |
w3list | Util.W3CSSHTML |
w3panel | Recognize.Data.DiagnoseResult |
w3right | Recognize.Data.DiagnoseResult |
w3table | Util.W3CSSHTML |
w3tags | Util.W3CSSHTML |
whereDidWeGoWrong | Task.MagicTrick.Recognizer |
wildcard | |
1 (Function) | Recognize.Expr.Symbols |
2 (Function) | Util.Expr |
wildcardRelation | Recognize.Expr.Symbols |
wildcardsToVars | Util.Expr |
wildcardSymbol | Recognize.Expr.Symbols |
withConstantFolding | Domain.Math.Simplification |
withDistribution | Domain.Math.Simplification |
withGuard | Util.Monad |
within | Domain.Math.Approximation |
withInput | Recognize.Parsing.Derived |
withInputList | Recognize.Parsing.Parse |
withMergeAlike | Domain.Math.Simplification |
withModulo | Recognize.Parsing.Interpretation |
withoutFailure | Recognize.Model.Assess |
withSimplifySquareRoot | Domain.Math.Simplification |
withSmartConstructors | Domain.Math.Simplification |
wrap | Util.String |
writeCache | Util.Cache |
writeFileMsg | Main.Diagnose |
writeOutput | Main.Diagnose |
writePage | Util.W3CSSHTML |
writeTerm | Domain.Math.Polynomial.BalanceUtils |
writeWith | Domain.Math.Polynomial.BalanceUtils |
zeroPower | Domain.Math.Power.Rules |
|> | Recognize.Parsing.Parse |