quantified.uncertainty/squiggle
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: Cleanup of Danger namespace

Browse Source
This commit is contained in:
NunoSempere 2022-09-05 12:38:15 +02:00
parent 6d75af61c3
commit a45e38d75d
1 changed files with 112 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
packages/squiggle-lang/src/rescript/FunctionRegistry/Library/FR_Danger.res
View File

@ -4,7 +4,8 @@ open FunctionRegistry_Helpers
let nameSpace = "Danger"
let requiresNamespace = true
module NumberToNumber = {
module NNumbersToNumber = {
module One = {
let make = (name, fn) =>
FnDefinition.make(
~name,
@ -20,7 +21,7 @@ module NumberToNumber = {
)
}
module TwoNumbersToNumber = {
module Two = {
let make = (name, fn) =>
FnDefinition.make(
~name,
@ -32,7 +33,7 @@ module TwoNumbersToNumber = {
)
}
module ThreeNumbersToNumber = {
module Three = {
let make = (name, fn) =>
FnDefinition.make(
~name,
@ -43,17 +44,6 @@ module ThreeNumbersToNumber = {
(),
)
}
module FunctionToNumberZero = {
let make = (name, _) =>
FnDefinition.make(
~name,
~inputs=[FRTypeLambda],
~run=(_, _, _, _) => {
Ok(0.0)->E.R2.fmap(Wrappers.evNumber)
},
(),
)
}
module Internals = {
@ -62,6 +52,7 @@ module Internals = {
let choose = ((n, k)) => factorial(n) /. (factorial(n -. k) *. factorial(k))
let pow = (base, exp) => Js.Math.pow_float(~base, ~exp)
let binomial = ((n, k, p)) => choose((n, k)) *. pow(p, k) *. pow(1.0 -. p, n -. k)
// Integral helper functions
let applyFunctionAtPoint = (
aLambda,
@ -69,31 +60,30 @@ module Internals = {
environment,
reducer,
): result<ReducerInterface_InternalExpressionValue.t, Reducer_ErrorValue.errorValue> => {
let x = internalNumber
let result = Reducer_Expression_Lambda.doLambdaCall(aLambda, list{x}, environment, reducer)
let result = Reducer_Expression_Lambda.doLambdaCall(
aLambda,
list{internalNumber},
environment,
reducer,
)
result
}
let internalZero = ReducerInterface_InternalExpressionValue.IEvNumber(0.0)
let applyFunctionAtZero = (aLambda, environment, reducer) =>
applyFunctionAtPoint(aLambda, internalZero, environment, reducer)
let castFloatToInternalNumber = x => ReducerInterface_InternalExpressionValue.IEvNumber(x)
@dead
let applyFunctionAtFloat = (aLambda, point, environment, reducer) =>
applyFunctionAtPoint(
aLambda,
ReducerInterface_InternalExpressionValue.IEvNumber(point),
environment,
reducer,
)
// simplest integral function
let integrateFunctionBetweenWithIncrement = (
// reason for existence: might be an useful template to have for calculating diminishing marginal returns later on
applyFunctionAtPoint(aLambda, castFloatToInternalNumber(point), environment, reducer)
// integrate function itself
let integrateFunctionBetweenWithNumIntegrationPoints = (
aLambda,
min: float,
max: float,
increment: float,
numIntegrationPoints: float, // cast as int?
environment,
reducer,
) => {
let applyFunctionAtFloatToFloatOption = (point: float) => {
// Defined here so that it has access to environment, reducer
let pointAsInternalExpression = ReducerInterface_InternalExpressionValue.IEvNumber(point)
let resultAsInternalExpression = Reducer_Expression_Lambda.doLambdaCall(
aLambda,
@ -103,54 +93,16 @@ module Internals = {
)
let result = switch resultAsInternalExpression {
| Ok(IEvNumber(x)) => Ok(x)
| Error(_) => Error("Integration error in Danger.integrate")
| _ => Error("Integration error in Danger.integrate")
}
result
}
let xsLength = Js.Math.floor((max -. min) /. increment) // Note that we are loosing a bit of the tail
let xs = Belt.Array.makeBy(xsLength, i => min +. (Belt_Float.fromInt(i) +. 0.5) *. increment)
// makeBy goes from 0 to (n-1): <https://rescript-lang.org/docs/manual/latest/api/belt/array#makeby>
let ysOptions = Belt.Array.map(xs, x => applyFunctionAtFloatToFloatOption(x))
let okYs = E.A.R.filterOk(ysOptions)
let result = switch E.A.length(ysOptions) == E.A.length(okYs) {
| true => {
let numericIntermediate = okYs->E.A.reduce(0.0, (a, b) => a +. b)
let numericIntermediate2 = numericIntermediate *. increment
let resultWrapped =
numericIntermediate2->ReducerInterface_InternalExpressionValue.IEvNumber->Ok
resultWrapped
}
| false => Error("Integration error in Danger.integrate")
}
result
}
// slightly better integrate function
let integrateFunctionBetweenWithNumIntervals = (
aLambda,
min: float,
max: float,
numIntervals: float, // cast as int?
environment,
reducer,
) => {
let applyFunctionAtFloatToFloatOption = (point: float) => {
let pointAsInternalExpression = ReducerInterface_InternalExpressionValue.IEvNumber(point)
let resultAsInternalExpression = Reducer_Expression_Lambda.doLambdaCall(
aLambda,
list{pointAsInternalExpression},
environment,
reducer,
| Error(_) =>
Error(
"Integration error in Danger.integrate. It's possible that your function doesn't return a number, try definining auxiliaryFunction(x) = mean(yourFunction(x)) and integrate auxiliaryFunction instead",
)
let result = switch resultAsInternalExpression {
| Ok(IEvNumber(x)) => Ok(x)
| Error(_) => Error("Integration error in Danger.integrate")
| _ => Error("Integration error in Danger.integrate")
}
result
}
// worked example in comments below, assuming min=0, max = 10
let numTotalPoints = Belt.Float.toInt(numIntervals)
let numTotalPoints = Belt.Float.toInt(numIntegrationPoints) // superflous declaration, but useful to keep track that we are interpreting "numIntegrationPoints" as the total number on which we evaluate the function, not e.g., as the inner integration points.
let numInnerPoints = numTotalPoints - 2
let numOuterPoints = 2
let totalWeight = max -. min
@ -160,12 +112,15 @@ module Internals = {
let innerXs = Belt.Array.makeBy(numInnerPoints, i =>
min +. Belt_Float.fromInt(i + 1) *. innerPointIncrement
)
// Note that makeBy goes from 0 to (n-1): <https://rescript-lang.org/docs/manual/latest/api/belt/array#makeby>
// Gotcha: makeBy goes from 0 to (n-1): <https://rescript-lang.org/docs/manual/latest/api/belt/array#makeby>
let ysOptions = Belt.Array.map(innerXs, x => applyFunctionAtFloatToFloatOption(x))
let okYs = E.A.R.filterOk(ysOptions)
// Logging
// assuming min = 0, max = 10, results below:
/* Logging, with a worked example. */
// Useful for understanding what is happening.
// assuming min = 0, max = 10, numTotalPoints=10, results below:
let verbose = false
if verbose {
Js.Console.log2("numTotalPoints", numTotalPoints) // 5
Js.Console.log2("numInnerPoints", numInnerPoints) // 3
Js.Console.log2("numOuterPoints", numOuterPoints) // always 2
@ -186,6 +141,7 @@ module Internals = {
Js.Console.log2("innerXs", innerXs) // 2.5, 5, 7.5
Js.Console.log2("ysOptions", ysOptions)
Js.Console.log2("okYs", okYs)
}
let result = switch E.A.length(ysOptions) == E.A.length(okYs) {
| true => {
@ -220,7 +176,7 @@ let library = [
~output=EvtNumber,
~examples=[`Danger.laplace(1, 20)`],
~definitions=[
TwoNumbersToNumber.make("laplace", ((successes, trials)) =>
NNumbersToNumber.Two.make("laplace", ((successes, trials)) =>
(successes +. 1.0) /. (trials +. 2.0)
),
],
@ -232,7 +188,7 @@ let library = [
~requiresNamespace,
~output=EvtNumber,
~examples=[`Danger.factorial(20)`],
~definitions=[NumberToNumber.make("factorial", Internals.factorial)],
~definitions=[NNumbersToNumber.One.make("factorial", Internals.factorial)],
(),
),
Function.make(
@ -241,7 +197,7 @@ let library = [
~requiresNamespace,
~output=EvtNumber,
~examples=[`Danger.choose(1, 20)`],
~definitions=[TwoNumbersToNumber.make("choose", Internals.choose)],
~definitions=[NNumbersToNumber.Two.make("choose", Internals.choose)],
(),
),
Function.make(
@ -250,19 +206,10 @@ let library = [
~requiresNamespace,
~output=EvtNumber,
~examples=[`Danger.binomial(1, 20, 0.5)`],
~definitions=[ThreeNumbersToNumber.make("binomial", Internals.binomial)],
~definitions=[NNumbersToNumber.Three.make("binomial", Internals.binomial)],
(),
),
// Helper functions building up to the integral
Function.make(
~name="functionToZero",
~nameSpace,
~requiresNamespace,
~output=EvtNumber,
~examples=[`Danger.functionToZero({|x| x})`],
~definitions=[FunctionToNumberZero.make("functionToZero", x => x)],
(),
),
Function.make(
~name="applyFunctionAtZero",
~nameSpace,
@ -273,10 +220,15 @@ let library = [
FnDefinition.make(
~name="applyFunctionAtZero",
~inputs=[FRTypeLambda],
~run=(inputs, _, env, reducer) => {
~run=(inputs, _, environment, reducer) => {
let result = switch inputs {
| [IEvLambda(aLambda)] =>
Internals.applyFunctionAtZero(aLambda, env, reducer)->E.R2.errMap(_ => "Error!")
Internals.applyFunctionAtPoint(
aLambda,
Internals.castFloatToInternalNumber(0.0),
environment,
reducer,
)->E.R2.errMap(_ => "Error!")
| _ => Error(impossibleError)
}
result
@ -307,29 +259,31 @@ let library = [
],
(),
),
// simplest integral
// Integral in terms of function, min, max, num points
// Note that execution time will be more predictable, because it
// will only depend on num points and the complexity of the function
Function.make(
~name="integrateFunctionBetweenWithIncrement",
~name="integrateFunctionBetweenWithNumIntegrationPoints",
~nameSpace,
~output=EvtNumber,
~requiresNamespace=false,
~examples=[`Danger.integrateFunctionBetweenWithIncrement({|x| x+1}, 1, 10, 1)`],
~examples=[`Danger.integrateFunctionBetweenWithNumIntegrationPoints({|x| x+1}, 1, 10, 10)`],
// should be [x^2/2 + x]1_10 = (100/2 + 10) - (1/2 + 1) = 60 - 1.5 = 58.5
// https://www.wolframalpha.com/input?i=integrate+x%2B1+from+1+to+10
~definitions=[
FnDefinition.make(
~name="integrateFunctionBetweenWithIncrement",
~name="integrateFunctionBetweenWithNumIntegrationPoints",
~inputs=[FRTypeLambda, FRTypeNumber, FRTypeNumber, FRTypeNumber],
~run=(inputs, _, env, reducer) => {
let result = switch inputs {
| [_, _, _, IEvNumber(0.0)] =>
Error("Integration error in Danger.integrate: Increment can't be 0.")
| [IEvLambda(aLambda), IEvNumber(min), IEvNumber(max), IEvNumber(increment)] =>
Internals.integrateFunctionBetweenWithIncrement(
| [IEvLambda(aLambda), IEvNumber(min), IEvNumber(max), IEvNumber(numIntegrationPoints)] =>
Internals.integrateFunctionBetweenWithNumIntegrationPoints(
aLambda,
min,
max,
increment,
numIntegrationPoints,
env,
reducer,
)->E.R2.errMap(_ =>
@ -347,29 +301,30 @@ let library = [
],
(),
),
// Integral which is a bit more thoughtful
// Integral in terms of function, min, max, epsilon (distance between points)
// Note that execution time will be less predictable, because it
// will depend on min, max and epsilon together,
// as well and the complexity of the function
Function.make(
~name="integrateFunctionBetweenWithNumIntervals",
~name="integrateFunctionBetweenWithEpsilon",
~nameSpace,
~output=EvtNumber,
~requiresNamespace=false,
~examples=[`Danger.integrateFunctionBetweenWithNumIntervals({|x| x+1}, 1, 10, 10)`],
// should be [x^2/2 + x]1_10 = (100/2 + 10) - (1/2 + 1) = 60 - 1.5 = 58.5
// https://www.wolframalpha.com/input?i=integrate+x%2B1+from+1+to+10
~examples=[`Danger.integrateFunctionBetweenWithEpsilon({|x| x+1}, 1, 10, 1)`],
~definitions=[
FnDefinition.make(
~name="integrateFunctionBetweenWithNumIntervals",
~name="integrateFunctionBetweenWithEpsilon",
~inputs=[FRTypeLambda, FRTypeNumber, FRTypeNumber, FRTypeNumber],
~run=(inputs, _, env, reducer) => {
let result = switch inputs {
| [_, _, _, IEvNumber(0.0)] =>
Error("Integration error in Danger.integrate: Increment can't be 0.")
| [IEvLambda(aLambda), IEvNumber(min), IEvNumber(max), IEvNumber(numIntervals)] =>
Internals.integrateFunctionBetweenWithNumIntervals(
| [IEvLambda(aLambda), IEvNumber(min), IEvNumber(max), IEvNumber(epsilon)] =>
Internals.integrateFunctionBetweenWithNumIntegrationPoints(
aLambda,
min,
max,
numIntervals,
(max -. min) /. epsilon,
env,
reducer,
)->E.R2.errMap(_ =>