+
{buildNav(setRoute)}
+
+ {if (route.hash == "") {
+ React.null;
+ } else {
+ switch (HS.get(entriesByPath, route.hash)) {
+ | Some(navEntry) =>
+ switch (navEntry) {
+ | CompEntry(c) => renderEntry(c)
+ | FolderEntry(f) =>
+ /* Rendering immediate children */
+ (
+ f.children
+ |> E.L.fmap(child =>
+ switch (child) {
+ | CompEntry(c) =>
+
+ {renderEntry(c)}
+
+ | _ => React.null
+ }
+ )
+ |> E.L.toArray
+ )
+ ->React.array
+ }
+ | None =>
"Component not found"->React.string
+ };
+ }}
+
+
+
+
{"Basic Mixed Distribution" |> ReasonReact.string}
+
+
+
{"Time Distribution" |> ReasonReact.string}
+
+
+
{"Domain Limited Distribution" |> ReasonReact.string}
+
+
setX(_ => r)}
+ />,
+ [|data|],
+ );
+
+ chart
+
+
+
+ {"X Point" |> ReasonReact.string}
+ {"Y Pount" |> ReasonReact.string}
+
+ {"Y Integral to Point" |> ReasonReact.string}
+
+
+
+
+
+
+ {x |> E.Float.toString |> ReasonReact.string}
+
+
+ {Shape.Continuous.findY(x, data)
+ |> E.Float.with2DigitsPrecision
+ |> ReasonReact.string}
+
+
+ {Shape.Continuous.findY(x, Shape.XYShape.integral(data))
+ |> E.Float.with2DigitsPrecision
+ |> ReasonReact.string}
+
+
+
+
+
+
+ Shape.Continuous.toPdf} />
+ {d |> Shape.Discrete.scaleYToTotal(f) |> Shape.Discrete.render}
+
+ | _ =>
+ };
+};
\ No newline at end of file
diff --git a/src/components/charts/cdfChartReact.js b/src/components/charts/cdfChartReact.js
new file mode 100644
index 00000000..f72e5db7
--- /dev/null
+++ b/src/components/charts/cdfChartReact.js
@@ -0,0 +1,66 @@
+import React, { useEffect } from 'react';
+import { useSize } from 'react-use';
+
+import chart from './cdfChartd3';
+
+/**
+ * @param min
+ * @param max
+ * @returns {number}
+ */
+function getRandomInt(min, max) {
+ min = Math.ceil(min);
+ max = Math.floor(max);
+ return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Example input:
+ * {
+ * xs: [50,100,300,400,500,600],
+ * ys: [0.1, 0.4, 0.6, 0.7,0.8, 0.9]}
+ * }
+ */
+function CdfChart(props) {
+ const id = "chart-" + getRandomInt(0, 100000);
+ const [sized, { width }] = useSize(() => {
+ return React.createElement("div", {
+ key: "resizable-div",
+ });
+ }, {
+ width: props.width,
+ });
+
+ useEffect(() => {
+ chart()
+ .svgWidth(width)
+ .svgHeight(props.height)
+ .maxX(props.maxX)
+ .minX(props.minX)
+ .onHover(props.onHover)
+ .marginBottom(props.marginBottom || 15)
+ .marginLeft(5)
+ .marginRight(5)
+ .marginTop(5)
+ .showDistributionLines(props.showDistributionLines)
+ .verticalLine(props.verticalLine)
+ .showVerticalLine(props.showVerticalLine)
+ .container("#" + id)
+ .data({ primary: props.primaryDistribution }).render();
+ });
+
+ const style = !!props.width ? { width: props.width + "px" } : {};
+ const key = id;
+
+ return React.createElement("div", {
+ style: {
+ paddingLeft: "10px",
+ paddingRight: "10px",
+ },
+ }, [
+ sized,
+ React.createElement("div", { id, style, key }),
+ ]);
+}
+
+export default CdfChart;
diff --git a/src/components/charts/cdfChartd3.js b/src/components/charts/cdfChartd3.js
new file mode 100644
index 00000000..3b14cc28
--- /dev/null
+++ b/src/components/charts/cdfChartd3.js
@@ -0,0 +1,302 @@
+import * as d3 from 'd3';
+
+function chart() {
+ // Id for event handlings.
+ var attrs = {
+ id: 'ID' + Math.floor(Math.random() * 1000000),
+ svgWidth: 400,
+ svgHeight: 400,
+
+ marginTop: 5,
+ marginBottom: 5,
+ marginRight: 50,
+ marginLeft: 5,
+
+ container: 'body',
+ minX: false,
+ maxX: false,
+ scale: 'linear',
+ showDistributionLines: true,
+ areaColors: ['#E1E5EC', '#E1E5EC'],
+ logBase: 10,
+ verticalLine: 110,
+ showVerticalLine: true,
+ data: null,
+ onHover: (e) => {},
+ };
+
+ var main = function main() {
+ // Drawing containers.
+ var container = d3.select(attrs.container);
+
+ if (container.node() === null) {
+ return;
+ }
+
+ var containerRect = container.node().getBoundingClientRect();
+ if (containerRect.width > 0) {
+ attrs.svgWidth = containerRect.width;
+ }
+
+ // Calculated properties.
+ // id for event handlings.
+ var calc = {};
+ calc.id = 'ID' + Math.floor(Math.random() * 1000000);
+ calc.chartLeftMargin = attrs.marginLeft;
+ calc.chartTopMargin = attrs.marginTop;
+ calc.chartWidth = attrs.svgWidth - attrs.marginRight - attrs.marginLeft;
+ calc.chartHeight = attrs.svgHeight - attrs.marginBottom - attrs.marginTop;
+
+ var areaColor = d3.scaleOrdinal().range(attrs.areaColors);
+
+ var dataPoints = [getDatapoints('primary')];
+
+ // Scales.
+ var xScale;
+
+ var xMin = d3.min(attrs.data.primary.xs);
+ var xMax = d3.max(attrs.data.primary.xs);
+
+ if (attrs.scale === 'linear') {
+ xScale = d3.scaleLinear()
+ .domain([
+ attrs.minX || xMin,
+ attrs.maxX || xMax
+ ])
+ .range([0, calc.chartWidth]);
+ } else {
+ xScale = d3.scaleLog()
+ .base(attrs.logBase)
+ .domain([
+ attrs.minX,
+ attrs.maxX,
+ ])
+ .range([0, calc.chartWidth]);
+ }
+
+ var yMin = d3.min(attrs.data.primary.ys);
+ var yMax = d3.max(attrs.data.primary.ys);
+
+ var yScale = d3.scaleLinear()
+ .domain([
+ yMin,
+ yMax,
+ ])
+ .range([calc.chartHeight, 0]);
+
+ // Axis generator.
+ var xAxis = d3.axisBottom(xScale)
+ .ticks(3)
+ .tickFormat(d => {
+ if (Math.abs(d) < 1) {
+ return d3.format(".2")(d);
+ } else if (xMin > 1000 && xMax < 3000) {
+ // Condition which identifies years; 2019, 2020, 2021.
+ return d3.format(".0")(d);
+ } else {
+ var prefix = d3.formatPrefix(".0", d);
+ var output = prefix(d);
+ return output.replace("G", "B");
+ }
+ });
+
+ // Line generator.
+ var line = d3.line()
+ .x(function (d, i) {
+ return xScale(d.x);
+ })
+ .y(function (d, i) {
+ return yScale(d.y);
+ });
+
+ var area = d3.area()
+ .x(function (d, i) {
+ return xScale(d.x);
+ })
+ .y1(function (d, i) {
+ return yScale(d.y);
+ })
+ .y0(calc.chartHeight);
+
+ // Add svg.
+ var svg = container
+ .patternify({ tag: 'svg', selector: 'svg-chart-container' })
+ .attr('width', "100%")
+ .attr('height', attrs.svgHeight)
+ .attr('pointer-events', 'none');
+
+ // Add container g element.
+ var chart = svg
+ .patternify({ tag: 'g', selector: 'chart' })
+ .attr(
+ 'transform',
+ 'translate(' + calc.chartLeftMargin + ',' + calc.chartTopMargin + ')',
+ );
+
+ // Add axis.
+ chart.patternify({ tag: 'g', selector: 'axis' })
+ .attr('transform', 'translate(' + 0 + ',' + calc.chartHeight + ')')
+ .call(xAxis);
+
+ // Draw area.
+ chart
+ .patternify({
+ tag: 'path',
+ selector: 'area-path',
+ data: dataPoints
+ })
+ .attr('d', area)
+ .attr('fill', (d, i) => areaColor(i))
+ .attr('opacity', (d, i) => i === 0 ? 0.7 : 1);
+
+ // Draw line.
+ if (attrs.showDistributionLines) {
+ chart
+ .patternify({
+ tag: 'path',
+ selector: 'line-path',
+ data: dataPoints
+ })
+ .attr('d', line)
+ .attr('id', (d, i) => 'line-' + (i + 1))
+ .attr('opacity', (d, i) => {
+ return i === 0 ? 0.7 : 1
+ })
+ .attr('fill', 'none');
+ }
+
+ if (attrs.showVerticalLine) {
+ chart.patternify({ tag: 'line', selector: 'v-line' })
+ .attr('x1', xScale(attrs.verticalLine))
+ .attr('x2', xScale(attrs.verticalLine))
+ .attr('y1', 0)
+ .attr('y2', calc.chartHeight)
+ .attr('stroke-width', 1.5)
+ .attr('stroke-dasharray', '6 6')
+ .attr('stroke', 'steelblue');
+ }
+
+ var hoverLine = chart.patternify({ tag: 'line', selector: 'hover-line' })
+ .attr('x1', 0)
+ .attr('x2', 0)
+ .attr('y1', 0)
+ .attr('y2', calc.chartHeight)
+ .attr('opacity', 0)
+ .attr('stroke-width', 1.5)
+ .attr('stroke-dasharray', '6 6')
+ .attr('stroke', '#22313F');
+
+ // Add drawing rectangle.
+ chart.patternify({ tag: 'rect', selector: 'mouse-rect' })
+ .attr('width', calc.chartWidth)
+ .attr('height', calc.chartHeight)
+ .attr('fill', 'transparent')
+ .attr('pointer-events', 'all')
+ .on('mouseover', mouseover)
+ .on('mousemove', mouseover)
+ .on('mouseout', mouseout);
+
+ function mouseover() {
+ var mouse = d3.mouse(this);
+
+ hoverLine.attr('opacity', 1)
+ .attr('x1', mouse[0])
+ .attr('x2', mouse[0]);
+
+ var range = [
+ xScale(dataPoints[dataPoints.length - 1][0].x),
+ xScale(
+ dataPoints
+ [dataPoints.length - 1]
+ [dataPoints[dataPoints.length - 1].length - 1].x,
+ ),
+ ];
+
+ var xValue = xScale.invert(mouse[0]).toFixed(2);
+
+ if (mouse[0] > range[0] && mouse[0] < range[1]) {
+ attrs.onHover(xValue);
+ } else {
+ attrs.onHover(0.0);
+ }
+ }
+
+ function mouseout() {
+ hoverLine.attr('opacity', 0)
+ }
+
+ /**
+ * @param key
+ * @returns {[]}
+ */
+ function getDatapoints(key) {
+ var dt = [];
+ var data = attrs.data[key];
+ var len = data.xs.length;
+
+ for (let i = 0; i < len; i++) {
+ dt.push({
+ x: data.xs[i],
+ y: data.ys[i]
+ })
+ }
+
+ return dt;
+ }
+ };
+
+ d3.selection.prototype.patternify = function patternify(params) {
+ var container = this;
+ var selector = params.selector;
+ var elementTag = params.tag;
+ var data = params.data || [selector];
+
+ // Pattern in action.
+ var selection = container.selectAll('.' + selector).data(data, (d, i) => {
+ if (typeof d === 'object') {
+ if (d.id) {
+ return d.id;
+ }
+ }
+ return i;
+ });
+
+ selection.exit().remove();
+ selection = selection.enter().append(elementTag).merge(selection);
+ selection.attr('class', selector);
+ return selection;
+ };
+
+ // @todo: Do not do like that.
+ // Dynamic keys functions.
+ // Attach variables to main function.
+ Object.keys(attrs).forEach((key) => {
+ main[key] = function (_) {
+ if (!arguments.length) {
+ return attrs[key];
+ }
+ attrs[key] = _;
+ return main;
+ };
+ });
+
+ //Set attrs as property.
+ main.attrs = attrs;
+
+ //Exposed update functions.
+ main.data = function data(value) {
+ if (!arguments.length) return attrs.data;
+ attrs.data = value;
+ return main;
+ };
+
+ // Run visual.
+ main.render = function render() {
+ main();
+ return main;
+ };
+
+ return main;
+}
+
+export default chart;
diff --git a/src/core/DistributionTypes.re b/src/core/DistributionTypes.re
new file mode 100644
index 00000000..d19070df
--- /dev/null
+++ b/src/core/DistributionTypes.re
@@ -0,0 +1,49 @@
+type domainLimit = {
+ xPoint: float,
+ excludingProbabilityMass: float,
+};
+
+type domain =
+ | Complete
+ | LeftLimited(domainLimit)
+ | RightLimited(domainLimit)
+ | LeftAndRightLimited(domainLimit, domainLimit);
+
+type xyShape = {
+ xs: array(float),
+ ys: array(float),
+};
+
+type continuousShape = xyShape;
+type discreteShape = xyShape;
+
+type mixedShape = {
+ continuous: continuousShape,
+ discrete: discreteShape,
+ discreteProbabilityMassFraction: float,
+};
+
+type pointsType =
+ | Mixed(mixedShape)
+ | Discrete(discreteShape)
+ | Continuous(continuousShape);
+
+type generationSource =
+ | GuesstimatorString(string)
+ | Shape(pointsType);
+
+type distributionUnit =
+ | Unspecified
+ | Time(TimeTypes.timeVector);
+
+type probabilityType =
+ | Cdf
+ | Pdf
+ | Arbitrary;
+
+type genericDistribution = {
+ generationSource,
+ probabilityType,
+ domain,
+ unit: distributionUnit,
+};
\ No newline at end of file
diff --git a/src/core/GenericDistribution.re b/src/core/GenericDistribution.re
new file mode 100644
index 00000000..515382e6
--- /dev/null
+++ b/src/core/GenericDistribution.re
@@ -0,0 +1,34 @@
+open DistributionTypes;
+let make =
+ (
+ ~generationSource,
+ ~probabilityType=Pdf,
+ ~domain=Complete,
+ ~unit=Unspecified,
+ (),
+ )
+ : genericDistribution => {
+ generationSource,
+ probabilityType,
+ domain,
+ unit,
+};
+
+let renderIfNeeded =
+ (~sampleCount=1000, t: genericDistribution): option(genericDistribution) => {
+ switch (t.generationSource) {
+ | GuesstimatorString(s) =>
+ let shape = Guesstimator.stringToMixedShape(~string=s, ~sampleCount, ());
+ shape
+ |> E.O.fmap((shape: DistributionTypes.mixedShape) =>
+ make(
+ ~generationSource=Shape(Mixed(shape)),
+ ~probabilityType=Cdf,
+ ~domain=t.domain,
+ ~unit=t.unit,
+ (),
+ )
+ );
+ | Shape(_) => Some(t)
+ };
+};
\ No newline at end of file
diff --git a/src/core/MixedCdf.re b/src/core/MixedCdf.re
new file mode 100644
index 00000000..2006df48
--- /dev/null
+++ b/src/core/MixedCdf.re
@@ -0,0 +1,14 @@
+type t = DistributionTypes.mixedShape;
+
+type yPdfPoint = {
+ continuous: float,
+ discrete: float,
+};
+
+let getY = (t: t, x: float): yPdfPoint => {
+ continuous: Shape.Continuous.findY(x, t.continuous),
+ discrete: Shape.Discrete.findY(x, t.discrete),
+} /* discrete: Shape.Discrete.findY(x, t.discrete)*/;
+
+// let getIntegralY = (t: t, x: float): float => {
+// continuous: Shape.Continuous.findY(x, t.continuous),
\ No newline at end of file
diff --git a/src/core/MixedShapeBuilder.re b/src/core/MixedShapeBuilder.re
new file mode 100644
index 00000000..9ed0ca0a
--- /dev/null
+++ b/src/core/MixedShapeBuilder.re
@@ -0,0 +1,63 @@
+type assumption =
+ | ADDS_TO_1
+ | ADDS_TO_CORRECT_PROBABILITY;
+type assumptions = {
+ continuous: assumption,
+ discrete: assumption,
+ discreteProbabilityMass: option(float),
+};
+let build = (~continuous, ~discrete, ~assumptions) =>
+ switch (assumptions) {
+ | {
+ continuous: ADDS_TO_CORRECT_PROBABILITY,
+ discrete: ADDS_TO_CORRECT_PROBABILITY,
+ discreteProbabilityMass: Some(r),
+ } =>
+ // TODO: Fix this, it's wrong :(
+ Some(
+ Shape.Mixed.make(
+ ~continuous,
+ ~discrete,
+ ~discreteProbabilityMassFraction=r,
+ ),
+ )
+ | {
+ continuous: ADDS_TO_1,
+ discrete: ADDS_TO_1,
+ discreteProbabilityMass: Some(r),
+ } =>
+ Some(
+ Shape.Mixed.make(
+ ~continuous,
+ ~discrete,
+ ~discreteProbabilityMassFraction=r,
+ ),
+ )
+ | {
+ continuous: ADDS_TO_1,
+ discrete: ADDS_TO_1,
+ discreteProbabilityMass: None,
+ } =>
+ None
+ | {
+ continuous: ADDS_TO_CORRECT_PROBABILITY,
+ discrete: ADDS_TO_1,
+ discreteProbabilityMass: None,
+ } =>
+ None
+ | {
+ continuous: ADDS_TO_1,
+ discrete: ADDS_TO_CORRECT_PROBABILITY,
+ discreteProbabilityMass: None,
+ } =>
+ let discreteProbabilityMassFraction = Shape.Discrete.ySum(discrete);
+ let discrete = Shape.Discrete.scaleYToTotal(1.0, discrete);
+ Some(
+ Shape.Mixed.make(
+ ~continuous,
+ ~discrete,
+ ~discreteProbabilityMassFraction,
+ ),
+ );
+ | _ => None
+ };
\ No newline at end of file
diff --git a/src/core/Shape.re b/src/core/Shape.re
new file mode 100644
index 00000000..7d0ebe06
--- /dev/null
+++ b/src/core/Shape.re
@@ -0,0 +1,107 @@
+open DistributionTypes;
+
+let _lastElement = (a: array('a)) =>
+ switch (Belt.Array.size(a)) {
+ | 0 => None
+ | n => Belt.Array.get(a, n - 1)
+ };
+
+module XYShape = {
+ type t = xyShape;
+
+ let toJs = (t: t) => {
+ {"xs": t.xs, "ys": t.ys};
+ };
+
+ let fmap = (t: t, y): t => {xs: t.xs, ys: t.ys |> E.A.fmap(y)};
+
+ let yFold = (fn, t: t) => {
+ E.A.fold_left(fn, 0., t.ys);
+ };
+
+ let ySum = yFold((a, b) => a +. b);
+
+ let fromArrays = (xs, ys): t => {xs, ys};
+
+ let transverse = (fn, p: t) => {
+ let (xs, ys) =
+ Belt.Array.zip(p.xs, p.ys)
+ ->Belt.Array.reduce([||], (items, (x, y)) =>
+ switch (_lastElement(items)) {
+ | Some((_, yLast)) =>
+ Belt.Array.concat(items, [|(x, fn(y, yLast))|])
+ | None => [|(x, y)|]
+ }
+ )
+ |> Belt.Array.unzip;
+ fromArrays(xs, ys);
+ };
+
+ let integral = transverse((aCurrent, aLast) => aCurrent +. aLast);
+ let derivative = transverse((aCurrent, aLast) => aCurrent -. aLast);
+};
+
+module Continuous = {
+ let fromArrays = XYShape.fromArrays;
+ let toJs = XYShape.toJs;
+ let toPdf = CdfLibrary.Distribution.toPdf;
+ let toCdf = CdfLibrary.Distribution.toCdf;
+ let findX = CdfLibrary.Distribution.findX;
+ let findY = CdfLibrary.Distribution.findY;
+};
+
+module Discrete = {
+ type t = discreteShape;
+ let fromArrays = XYShape.fromArrays;
+ let toJs = XYShape.toJs;
+ let ySum = XYShape.ySum;
+ let zip = t => Belt.Array.zip(t.xs, t.ys);
+
+ let scaleYToTotal = (totalDesired, t: t): t => {
+ let difference = totalDesired /. ySum(t);
+ XYShape.fmap(t, y => y *. difference);
+ };
+
+ let render = (t: t) =>
+ Belt.Array.zip(t.xs, t.ys)
+ |> E.A.fmap(((x, y)) =>
+
+ {E.Float.toFixed(x)
+ ++ "---"
+ ++ E.Float.with3DigitsPrecision(y *. 100.)
+ |> ReasonReact.string}
+
+ )
+ |> ReasonReact.array;
+
+ let findY = (x: float, t: t) =>
+ switch (E.A.getBy(zip(t), ((ix, _)) => ix == x)) {
+ | Some((_, y)) => y
+ | None => 0.
+ };
+};
+
+module Mixed = {
+ let make = (~continuous, ~discrete, ~discreteProbabilityMassFraction) => {
+ continuous,
+ discrete,
+ discreteProbabilityMassFraction,
+ };
+
+ type yPdfPoint = {
+ continuous: float,
+ discrete: float,
+ };
+
+ let getY = (t: DistributionTypes.mixedShape, x: float): yPdfPoint => {
+ continuous: Continuous.findY(x, t.continuous),
+ discrete: Discrete.findY(x, t.discrete),
+ };
+};
+
+module DomainMixed = {
+ type t = {
+ mixedShape,
+ domain,
+ };
+};
\ No newline at end of file
diff --git a/src/core/TimeTypes.re b/src/core/TimeTypes.re
new file mode 100644
index 00000000..db08c5bd
--- /dev/null
+++ b/src/core/TimeTypes.re
@@ -0,0 +1,59 @@
+type timeUnit = [
+ | `days
+ | `hours
+ | `milliseconds
+ | `minutes
+ | `months
+ | `quarters
+ | `seconds
+ | `weeks
+ | `years
+];
+
+type timeVector = {
+ zero: MomentRe.Moment.t,
+ unit: timeUnit,
+};
+
+type timePoint = {
+ timeVector,
+ value: float,
+};
+
+module TimePoint = {
+ let fromTimeVector = (timeVector, value): timePoint => {timeVector, value};
+
+ let toMoment = (timePoint: timePoint) => {
+ timePoint.timeVector.zero
+ |> MomentRe.Moment.add(
+ ~duration=
+ MomentRe.duration(timePoint.value, timePoint.timeVector.unit),
+ );
+ };
+
+ let fromMoment = (timeVector: timeVector, moment: MomentRe.Moment.t) =>
+ MomentRe.diff(timeVector.zero, moment, timeVector.unit);
+};
+
+module RelativeTimePoint = {
+ type timeInVector =
+ | Time(MomentRe.Moment.t)
+ | XValue(float);
+
+ let toTime = (timeVector: timeVector, timeInVector: timeInVector) =>
+ switch (timeInVector) {
+ | Time(r) => r
+ | XValue(r) =>
+ timeVector.zero
+ |> MomentRe.Moment.add(~duration=MomentRe.duration(r, timeVector.unit))
+ };
+
+ let _timeToX = (time, timeStart, timeUnit) =>
+ MomentRe.diff(timeStart, time, timeUnit);
+
+ let toXValue = (timeVector: timeVector, timeInVector: timeInVector) =>
+ switch (timeInVector) {
+ | Time(r) => _timeToX(r, timeVector.zero, timeVector.unit)
+ | XValue(r) => r
+ };
+};
\ No newline at end of file
diff --git a/src/index.html b/src/index.html
index c157a5aa..80546e46 100644
--- a/src/index.html
+++ b/src/index.html
@@ -3,7 +3,7 @@
Foretold.io
+ Estiband
+ Shape.Continuous.toJs} />
+ {d |> Shape.Discrete.scaleYToTotal(f) |> Shape.Discrete.render}
+
+ | None => "Something went wrong" |> ReasonReact.string
+ | _ =>
+ };
+ | FloatCdf(_) =>
+ | Probability(r) =>
+ (r *. 100. |> Js.Float.toFixed) ++ "%" |> ReasonReact.string
+ | DateTime(r) => r |> MomentRe.Moment.defaultFormat |> ReasonReact.string
+ | FloatPoint(r) => r |> Js.Float.toFixed |> ReasonReact.string
+ };
+};
+
module ModelForm = {
let handleChange = (handleChange, event) =>
handleChange(ReactEvent.Form.target(event)##value);
@@ -51,10 +84,8 @@ module ModelForm = {
)
|> ReasonReact.array}
- {model.run(formState.combo)
- |> E.O.fmap(Value.to_string)
- |> E.O.default("")
- |> ReasonReact.string}
+ {model.run(Prop.Combo.InputValues.toValueArray(formState.combo))
+ |> E.O.React.fmapOrNull(propValue)}
;
diff --git a/src/lib/Prop.re b/src/interface/Prop.re
similarity index 58%
rename from src/lib/Prop.re
rename to src/interface/Prop.re
index 46f6dd17..c2a33e23 100644
--- a/src/lib/Prop.re
+++ b/src/interface/Prop.re
@@ -1,31 +1,95 @@
module Value = {
- type binaryConditional =
- | Selected(bool)
- | Unselected;
+ type conditional = {
+ name: string,
+ truthValue: bool,
+ };
+
type t =
- | BinaryConditional(binaryConditional)
| SelectSingle(string)
| DateTime(MomentRe.Moment.t)
| FloatPoint(float)
| Probability(float)
+ | GenericDistribution(DistributionTypes.genericDistribution)
+ | ConditionalArray(array(conditional))
| FloatCdf(string);
- let to_string = (t: t) => {
- switch (t) {
- | BinaryConditional(binaryConditional) =>
- switch (binaryConditional) {
- | Selected(r) => r ? "True" : "False"
- | Unselected => ""
- }
- | SelectSingle(r) => r
- | FloatCdf(r) => r
- | Probability(r) => (r *. 100. |> Js.Float.toFixed) ++ "%"
- | DateTime(r) => r |> MomentRe.Moment.defaultFormat
- | FloatPoint(r) => r |> Js.Float.toFixed
- };
+ module ConditionalArray = {
+ let get = (conditionals: array(conditional), name: string) =>
+ Belt.Array.getBy(conditionals, (c: conditional) => c.name == name);
};
};
+module ValueCombination = {
+ type pointsToEvenlySample = int;
+
+ type dateTimeRange = {
+ startTime: MomentRe.Moment.t,
+ endTime: MomentRe.Moment.t,
+ pointsWithin: int,
+ };
+
+ type floatPointRange = {
+ startTime: float,
+ endTime: float,
+ pointsWithin: int,
+ };
+
+ type range('a) = {
+ beginning: 'a,
+ ending: 'a,
+ pointsToEvenlySample,
+ };
+
+ type t =
+ | SelectSingle
+ | DateTime(range(MomentRe.Moment.t))
+ | FloatPoint(range(MomentRe.Moment.t))
+ | Probability(pointsToEvenlySample);
+};
+
+module ValueCluster = {
+ type conditional = {
+ name: string,
+ truthValue: bool,
+ };
+
+ type pointsToEvenlySample = int;
+
+ type dateTimeRange = {
+ startTime: MomentRe.Moment.t,
+ endTime: MomentRe.Moment.t,
+ pointsWithin: int,
+ };
+
+ type floatPointRange = {
+ startTime: float,
+ endTime: float,
+ pointsWithin: int,
+ };
+
+ type range('a) = {
+ beginning: 'a,
+ ending: 'a,
+ pointsToEvenlySample,
+ };
+
+ type t =
+ | SelectSingle([ | `combination | `item(string)])
+ | DateTime(
+ [
+ | `combination(range(MomentRe.Moment.t))
+ | `item(MomentRe.Moment.t)
+ ],
+ )
+ | FloatPoint(
+ [ | `combination(range(MomentRe.Moment.t)) | `item(string)],
+ )
+ | Probability([ | `item(string)])
+ | GenericDistribution([ | `item(DistributionTypes.genericDistribution)])
+ | ConditionalArray([ | `item(array(conditional))])
+ | FloatCdf([ | `item(string)]);
+};
+
module Type = {
type selectOption = {
id: string,
@@ -37,6 +101,16 @@ module Type = {
default: option(string),
};
+ type conditionals = {
+ defaults: array(Value.conditional),
+ options: array(string),
+ };
+
+ let makeConditionals = (defaults, options): conditionals => {
+ defaults,
+ options,
+ };
+
type floatPoint = {validatations: list(float => bool)};
type withDefaultMinMax('a) = {
@@ -48,17 +122,17 @@ module Type = {
type withDefault('a) = {default: option('a)};
type t =
- | BinaryConditional
| SelectSingle(selectSingle)
| FloatPoint(withDefaultMinMax(float))
| Probability(withDefault(float))
| DateTime(withDefaultMinMax(MomentRe.Moment.t))
| Year(withDefaultMinMax(float))
+ | Conditionals(conditionals)
| FloatCdf;
let default = (t: t) =>
switch (t) {
- | BinaryConditional => Some(Value.BinaryConditional(Unselected))
+ | Conditionals(s) => Some(Value.ConditionalArray(s.defaults))
| Year(r) => r.default->Belt.Option.map(p => Value.FloatPoint(p))
| FloatPoint(r) => r.default->Belt.Option.map(p => Value.FloatPoint(p))
| Probability(r) => r.default->Belt.Option.map(p => Value.Probability(p))
@@ -85,6 +159,22 @@ module ValueMap = {
let fromOptionalArray = (r): t => MS.fromArray(r) |> fromOptionalMap;
};
+module ValueClusterMap = {
+ module MS = Belt.Map.String;
+ type t = MS.t(ValueCluster.t);
+ let get = (t: t, s) => MS.get(t, s);
+ let keys = MS.keysToArray;
+ let map = MS.map;
+ let fromArray = (r): t => MS.fromArray(r);
+ let values = (t: t) => t |> MS.valuesToArray;
+ let update = (t, k, v) => MS.update(t, k, _ => v);
+ let toArray = MS.toArray;
+ let fromOptionalMap = (t: MS.t(option(ValueCluster.t))): t =>
+ MS.keep(t, (_, d) => E.O.isSome(d))
+ ->MS.map(d => E.O.toExn("This should not have happened", d));
+ let fromOptionalArray = (r): t => MS.fromArray(r) |> fromOptionalMap;
+};
+
module TypeWithMetadata = {
// TODO: Figure out a better name for assumptionType
type assumptionType =
@@ -120,7 +210,7 @@ module TypeWithMetadata = {
let currentYear =
make(
~id="currentYear",
- ~name="Current Year",
+ ~name="Current Day",
~description=None,
~type_=
DateTime({
@@ -141,7 +231,7 @@ module Model = {
version: string,
inputTypes: array(TypeWithMetadata.t),
outputTypes: array(TypeWithMetadata.t),
- run: combo => option(Value.t),
+ run: array(option(Value.t)) => option(Value.t),
}
and combo = {
model: t,
@@ -152,11 +242,14 @@ module Model = {
module InputTypes = {
let keys = (t: t) =>
t.inputTypes |> E.A.fmap((r: TypeWithMetadata.t) => r.id);
+
+ let getBy = (t: t, fn) => t.inputTypes |> E.A.getBy(_, fn);
};
};
module Combo = {
type t = Model.combo;
+ type valueArray = array(option(Value.t));
module InputValues = {
let defaults = (t: Model.t) =>
@@ -173,10 +266,10 @@ module Combo = {
let update = (t: t, key: string, onUpdate: option(Value.t)) =>
ValueMap.update(t.inputValues, key, onUpdate);
- let toValueArray = (t: t) => {
+ let toValueArray = (t: t): valueArray => {
t.model.inputTypes
|> E.A.fmap((r: TypeWithMetadata.t) =>
- ValueMap.get(t.inputValues, r.id)
+ t.inputValues->ValueMap.get(r.id)
);
};
};
diff --git a/src/interface/ValueForm.re b/src/interface/ValueForm.re
new file mode 100644
index 00000000..2d746a20
--- /dev/null
+++ b/src/interface/ValueForm.re
@@ -0,0 +1,157 @@
+open Prop;
+let handleChange = (handleChange, event) =>
+ handleChange(ReactEvent.Form.target(event)##value);
+type onChange = option(Value.t) => unit;
+
+module ConditionalReducer = {
+ type action =
+ | ADD_OR_UPDATE_CONDITIONAL(Value.conditional)
+ | REMOVE_CONDITIONAL(Value.conditional);
+
+ let reducer = (items: array(Value.conditional), action: action) =>
+ switch (action) {
+ | ADD_OR_UPDATE_CONDITIONAL(conditional) =>
+ items->E.A.hasBy(c => c.name == conditional.name)
+ ? items
+ |> E.A.fmap((r: Value.conditional) =>
+ r.name == conditional.name ? conditional : r
+ )
+ : E.A.append(items, [|conditional|])
+ | REMOVE_CONDITIONAL(conditional) =>
+ items
+ |> E.A.filter((c: Value.conditional) => c.name != conditional.name)
+ };
+};
+
+[@react.component]
+let make =
+ (
+ ~type_: TypeWithMetadata.t,
+ ~value: option(Value.t),
+ ~onChange: onChange,
+ ) => {
+ switch (type_.type_, value) {
+ | (Conditionals(l), Some(ConditionalArray(n))) =>
+
+ {n
+ |> E.A.fmap((r: Value.conditional) =>
+
+ onChange(
+ Some(
+ Value.ConditionalArray(
+ ConditionalReducer.reducer(
+ n,
+ REMOVE_CONDITIONAL({name: r.name, truthValue: true}),
+ ),
+ ),
+ ),
+ )
+ }>
+ {r.name |> ReasonReact.string}
+ {(r.truthValue ? " = True" : " = False") |> ReasonReact.string}
+
+ )
+ |> ReasonReact.array}
+ {l.options
+ |> E.A.fmap(r =>
+
+ {r |> ReasonReact.string}
+ {
+ ReactEvent.Synthetic.preventDefault(e);
+ onChange(
+ Some(
+ Value.ConditionalArray(
+ ConditionalReducer.reducer(
+ n,
+ ADD_OR_UPDATE_CONDITIONAL({
+ name: r,
+ truthValue: true,
+ }),
+ ),
+ ),
+ ),
+ );
+ ();
+ }}>
+ {"=True" |> ReasonReact.string}
+
+ {
+ ReactEvent.Synthetic.preventDefault(e);
+ onChange(
+ Some(
+ Value.ConditionalArray(
+ ConditionalReducer.reducer(
+ n,
+ ADD_OR_UPDATE_CONDITIONAL({
+ name: r,
+ truthValue: false,
+ }),
+ ),
+ ),
+ ),
+ );
+ }}>
+ {"=False" |> ReasonReact.string}
+
+
+ )
+ |> ReasonReact.array}
+
onChange(Some(Value.SelectSingle(l))))}>
+ {t.options
+ |> E.A.of_list
+ |> E.A.fmap((l: Type.selectOption) =>
+
+ {l.name |> ReasonReact.string}
+
+ )
+ |> ReasonReact.array}
+
+ | (DateTime(_), Some(DateTime((d: MomentRe.Moment.t)))) =>
+
+
;
\ No newline at end of file
diff --git a/src/lib/E.re b/src/lib/E.re
index 177f4a85..298cb21e 100644
--- a/src/lib/E.re
+++ b/src/lib/E.re
@@ -211,6 +211,7 @@ module A = {
let unsafe_get = Array.unsafe_get;
let get = Belt.Array.get;
let getBy = Belt.Array.getBy;
+ let hasBy = (r, fn) => Belt.Array.getBy(r, fn) |> O.isSome;
let fold_left = Array.fold_left;
let fold_right = Array.fold_right;
let concatMany = Belt.Array.concatMany;
diff --git a/src/lib/FloatCdf.re b/src/lib/FloatCdf.re
deleted file mode 100644
index d94c209b..00000000
--- a/src/lib/FloatCdf.re
+++ /dev/null
@@ -1,10 +0,0 @@
-let normal = (mean: float, std: float) =>
- Js.Float.(
- {
- let nMean = toPrecisionWithPrecision(mean, ~digits=4);
- let nStd = toPrecisionWithPrecision(std, ~digits=2);
- {j|normal($(nMean), $(nStd))|j};
- }
- );
-
-let divide = (str1: string, str2: string) => {j|$(str1)/$(str2)|j};
\ No newline at end of file
diff --git a/src/lib/GuesstimatorDist.re b/src/lib/GuesstimatorDist.re
new file mode 100644
index 00000000..74f54e50
--- /dev/null
+++ b/src/lib/GuesstimatorDist.re
@@ -0,0 +1,21 @@
+let normal = (mean: float, std: float) =>
+ Js.Float.(
+ {
+ let nMean = toPrecisionWithPrecision(mean, ~digits=4);
+ let nStd = toPrecisionWithPrecision(std, ~digits=2);
+ {j|normal($(nMean), $(nStd))|j};
+ }
+ );
+
+let logNormal = (mean: float, std: float) => {
+ Js.Float.(
+ {
+ let nMean = toPrecisionWithPrecision(Js.Math.log10(mean), ~digits=4);
+ let nStd = toPrecisionWithPrecision(Js.Math.log10(std), ~digits=2);
+ {j|lognormal($(nMean), $(nStd))|j};
+ }
+ );
+};
+
+let divide = (str1: string, str2: string) => {j|$(str1)/$(str2)|j};
+let min = (str1: string, str2: string) => {j|min($(str1),$(str2))|j};
\ No newline at end of file
diff --git a/src/lib/ValueForm.re b/src/lib/ValueForm.re
deleted file mode 100644
index 89a0e812..00000000
--- a/src/lib/ValueForm.re
+++ /dev/null
@@ -1,93 +0,0 @@
-open Prop;
-let handleChange = (handleChange, event) =>
- handleChange(ReactEvent.Form.target(event)##value);
-type onChange = option(Value.t) => unit;
-
-[@react.component]
-let make =
- (
- ~type_: TypeWithMetadata.t,
- ~value: option(Value.t),
- ~onChange: onChange,
- ) => {
- switch (type_.type_, value) {
- | (Year(_), Some(FloatPoint(r))) =>
- onChange(Some(BinaryConditional(Selected(true))))}>
- {"Select" |> ReasonReact.string}
-
- | Selected(true) =>
-
- {"YES!" |> ReasonReact.string}
-
onChange(Some(BinaryConditional(Selected(false))))}>
- {"No" |> ReasonReact.string}
-
-
onChange(Some(BinaryConditional(Unselected)))}>
- {"Deselect" |> ReasonReact.string}
-
-
- {"NO!" |> ReasonReact.string}
-
onChange(Some(BinaryConditional(Selected(true))))}>
- {"Yes" |> ReasonReact.string}
-
-
onChange(Some(BinaryConditional(Unselected)))}>
- {"Deselect" |> ReasonReact.string}
-
-
onChange(Some(Value.SelectSingle(l))))}>
- {t.options
- |> E.A.of_list
- |> E.A.fmap((l: Type.selectOption) =>
-
- {l.name |> ReasonReact.string}
-
- )
- |> ReasonReact.array}
-
- | (DateTime(_), Some(DateTime((d: MomentRe.Moment.t)))) =>
-