@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/ConstrainToAngles.js

@@ -0,0 +1,244 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+
+export default class ConstrainToAngles extends ConstraintComponent {
+  static componentType = "constrainToAngles";
+
+  static returnChildLogic(args) {
+    let childLogic = super.returnChildLogic(args);
+
+    let addAngles = function ({ activeChildrenMatched }) {
+      // add <angles> around children
+      let anglesChildren = [];
+      for (let child of activeChildrenMatched) {
+        anglesChildren.push({
+          createdComponent: true,
+          componentName: child.componentName,
+        });
+      }
+      return {
+        success: true,
+        newChildren: [{ componentType: "angles", children: anglesChildren }],
+      };
+    };
+
+    let AtLeastOneAngle = childLogic.newLeaf({
+      name: "AtLeastOneAngle",
+      componentType: "angle",
+      comparison: "atLeast",
+      number: 1,
+      isSugar: true,
+      replacementFunction: addAngles,
+    });
+
+    let AtLeastOneString = childLogic.newLeaf({
+      name: "AtLeastOneString",
+      componentType: "string",
+      comparison: "atLeast",
+      number: 1,
+    });
+
+    let AtLeastOneMath = childLogic.newLeaf({
+      name: "AtLeastOneMath",
+      componentType: "math",
+      comparison: "atLeast",
+      number: 1,
+    });
+
+    let StringsAndMaths = childLogic.newOperator({
+      name: "StringsAndMaths",
+      operator: "or",
+      propositions: [AtLeastOneString, AtLeastOneMath],
+      requireConsecutive: true,
+      isSugar: true,
+      replacementFunction: addAngles,
+    });
+
+    let AtMostOneAngles = childLogic.newLeaf({
+      name: "AtMostOneAngles",
+      componentType: "angles",
+      comparison: "atMost",
+      number: 1,
+    });
+
+    let Angles = childLogic.newOperator({
+      name: "Angles",
+      operator: "xor",
+      propositions: [AtLeastOneAngle, StringsAndMaths, AtMostOneAngles],
+      setAsBase: true,
+    });
+
+    let AtMostOnePoint = childLogic.newLeaf({
+      name: "AtMostOnePoint",
+      componentType: "point",
+      comparison: "atMost",
+      number: 1,
+    });
+
+    childLogic.newOperator({
+      name: "AnglesAndPoint",
+      operator: "and",
+      propositions: [Angles, AtMostOnePoint],
+      setAsBase: true,
+    });
+
+    return childLogic;
+  }
+
+  updateState(args = {}) {
+    super.updateState(args);
+
+    if (!this.childLogicSatisfied) {
+      this.unresolvedState.angles = true;
+      this.unresolvedState.offset = true;
+      return;
+    }
+
+    let trackChanges = this.currentTracker.trackChanges;
+    let childrenChanged = trackChanges.childrenChanged(this.componentName);
+
+    if (childrenChanged) {
+      let anglesInd = this.childLogic.returnMatches("AtMostOneAngles");
+
+      if (anglesInd.length === 1) {
+        this.state.anglesChild = this.activeChildren[anglesInd[0]];
+      } else {
+        delete this.state.anglesChild;
+        this.state.angles = [];
+        delete this.unresolvedState.angles;
+      }
+
+      let pointInd = this.childLogic.returnMatches("AtMostOnePoint");
+      if (pointInd.length === 1) {
+        this.state.pointChild = this.activeChildren[pointInd[0]];
+      } else {
+        delete this.state.pointChild;
+        this.state.offset = [0, 0, 0];
+        delete this.unresolvedState.offset;
+      }
+    }
+
+    if (this.state.anglesChild) {
+      if (this.state.anglesChild.unresolvedState.angles) {
+        this.unresolvedState.angles = true;
+        return;
+      }
+
+      if (
+        childrenChanged ||
+        trackChanges.getVariableChanges({
+          component: this.state.anglesChild,
+          variable: "angles",
+        })
+      ) {
+        delete this.unresolvedState.angles;
+        this.state.angles = this.state.anglesChild.state.angles;
+      }
+    }
+
+    if (this.state.pointChild) {
+      if (this.state.pointChild.unresolvedState.xs) {
+        this.unresolvedState.offset = true;
+        return;
+      }
+
+      if (
+        childrenChanged ||
+        trackChanges.getVariableChanges({
+          component: this.state.pointChild,
+          variable: "xs",
+        })
+      ) {
+        delete this.unresolvedState.offset;
+
+        this.state.offset = [];
+        for (let i = 0; i < this.state.pointChild.state.ndimensions; i++) {
+          let temp = this.state.pointChild.state.xs[i].evaluate_to_constant();
+          if (!Number.isFinite(temp)) {
+            this.state.offset = NaN;
+            break;
+          }
+          this.state.offset.push(temp);
+        }
+      }
+    }
+  }
+
+  applyTheConstraint({ x1, x2, x3, offset }) {
+    // use the convention of x1, x2, and x3 for variable names
+    // so that components can call constraints generically for n-dimensions
+
+    if (this.unresolvedState.angles || this.unresolvedState.offset) {
+      return {};
+    }
+
+    // only works in 2D
+    if (x1 === undefined || x2 === undefined || x3 !== undefined) {
+      return {};
+    }
+
+    // only works for numerical x1 and x2
+    x1 = this.findFiniteNumericalValue(x1);
+    x2 = this.findFiniteNumericalValue(x2);
+
+    if (!Number.isFinite(x1) || !Number.isFinite(x2)) {
+      return {};
+    }
+
+    if (offset === undefined) {
+      offset = this.state.offset;
+    }
+
+    // if didn't get a numerical value for one of the offset components
+    // return no constraint
+    if (Number.isNaN(offset)) {
+      return {};
+    }
+
+    let dx1 = x1 - offset[0];
+    let dx2 = x2 - offset[1];
+
+    let foundAngle = Math.atan2(dx2, dx1);
+
+    let closestDistance = Infinity;
+    let closestAngle;
+    let closestInd;
+
+    for (let [ind, angleComp] of this.state.angles.entries()) {
+      let angle = angleComp.state.angle.evaluate_to_constant();
+
+      if (!Number.isFinite(angle)) {
+        continue;
+      }
+
+      let distanceToAngle = Math.abs(
+        ((angle - foundAngle + Math.PI) % (2 * Math.PI)) - Math.PI,
+      );
+
+      if (distanceToAngle < closestDistance) {
+        closestAngle = angle;
+        closestInd = ind;
+        closestDistance = distanceToAngle;
+      }
+    }
+
+    if (closestAngle === undefined) {
+      return {};
+    }
+
+    let mag = Math.sqrt(dx1 * dx1 + dx2 * dx2);
+
+    let newX1 = offset[0] + mag * Math.cos(closestAngle);
+    let newX2 = offset[1] + mag * Math.sin(closestAngle);
+
+    let result = {
+      variables: {
+        x1: newX1,
+        x2: newX2,
+      },
+      constraintIndices: [closestInd + 1],
+      constrained: true,
+    };
+
+    return result;
+  }
+}

package/src/Core/components/ConstrainToGraph.js

@@ -0,0 +1,142 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+import { findFiniteNumericalValue } from "../utils/math";
+
+export default class ConstrainToGraph extends ConstraintComponent {
+  static componentType = "constrainToGraph";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.buffer = {
+      createComponentOfType: "number",
+      createStateVariable: "buffer",
+      defaultValue: 0.01,
+      public: true,
+    };
+    return attributes;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.independentComponentConstraints = {
+      returnDependencies: () => ({}),
+      definition: () => ({
+        setValue: { independentComponentConstraints: true },
+      }),
+    };
+
+    // Since state variable independentComponentConstraints is true,
+    // expect function applyComponentConstraint to be called with
+    // a single component value as the object, for example,  {x1: 13}
+
+    // use the convention of x1, x2, and x3 for variable names
+    // so that components can call constraints generically for n-dimensions
+    // use x,y,z for properties so that authors can use the more familar tag names
+
+    stateVariableDefinitions.applyComponentConstraint = {
+      returnDependencies: () => ({
+        constraintAncestor: {
+          dependencyType: "ancestor",
+          componentType: "constraints",
+          variableNames: ["graphXmin", "graphXmax", "graphYmin", "graphYmax"],
+        },
+        buffer: {
+          dependencyType: "stateVariable",
+          variableName: "buffer",
+        },
+      }),
+      definition: ({ dependencyValues }) => ({
+        setValue: {
+          applyComponentConstraint: function (variables) {
+            if (
+              dependencyValues.constraintAncestor === null ||
+              dependencyValues.constraintAncestor.stateValues.graphXmin === null
+            ) {
+              return {};
+            }
+
+            // if given the value of x1, apply to constraint to x1
+            // and ignore any other arguments (which shouldn't be given)
+            if ("x1" in variables) {
+              let x1 = findFiniteNumericalValue(variables.x1);
+
+              // if found a non-numerical value, return no constraint
+              if (!Number.isFinite(x1)) {
+                return {};
+              }
+
+              let xmin =
+                dependencyValues.constraintAncestor.stateValues.graphXmin;
+              let xmax =
+                dependencyValues.constraintAncestor.stateValues.graphXmax;
+
+              if (!(Number.isFinite(xmin) && Number.isFinite(xmax))) {
+                return {};
+              }
+
+              let lowerBound = xmin;
+              let upperBound = xmax;
+              let buffer = dependencyValues.buffer;
+              if (buffer > 0) {
+                let bufferAdjust = buffer * (xmax - xmin);
+                lowerBound += bufferAdjust;
+                upperBound -= bufferAdjust;
+              }
+
+              let x1constrained = Math.max(
+                lowerBound,
+                Math.min(upperBound, x1),
+              );
+              return {
+                constrained: true,
+                variables: { x1: x1constrained },
+              };
+            }
+
+            // if given the value of x2, apply to constraint to x2
+            // and ignore any other arguments (which shouldn't be given)
+            if ("x2" in variables) {
+              let x2 = findFiniteNumericalValue(variables.x2);
+              // if found a non-numerical value, return no constraint
+              if (!Number.isFinite(x2)) {
+                return {};
+              }
+
+              let ymin =
+                dependencyValues.constraintAncestor.stateValues.graphYmin;
+              let ymax =
+                dependencyValues.constraintAncestor.stateValues.graphYmax;
+
+              if (!(Number.isFinite(ymin) && Number.isFinite(ymax))) {
+                return {};
+              }
+
+              let lowerBound = ymin;
+              let upperBound = ymax;
+              let buffer = dependencyValues.buffer;
+              if (buffer > 0) {
+                let bufferAdjust = buffer * (ymax - ymin);
+                lowerBound += bufferAdjust;
+                upperBound -= bufferAdjust;
+              }
+
+              let x2constrained = Math.max(
+                lowerBound,
+                Math.min(upperBound, x2),
+              );
+              return {
+                constrained: true,
+                variables: { x2: x2constrained },
+              };
+            }
+
+            // if didn't get x1, or x2 as argument, don't constrain anything
+            return {};
+          },
+        },
+      }),
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/ConstrainToGrid.js

@@ -0,0 +1,175 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+import { findFiniteNumericalValue } from "../utils/math";
+
+export default class ConstrainToGrid extends ConstraintComponent {
+  static componentType = "constrainToGrid";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.dx = {
+      createComponentOfType: "number",
+      createStateVariable: "dx",
+      defaultValue: 1,
+      public: true,
+    };
+    attributes.dy = {
+      createComponentOfType: "number",
+      createStateVariable: "dy",
+      defaultValue: 1,
+      public: true,
+    };
+    attributes.dz = {
+      createComponentOfType: "number",
+      createStateVariable: "dz",
+      defaultValue: 1,
+      public: true,
+    };
+    attributes.xoffset = {
+      createComponentOfType: "number",
+      createStateVariable: "xoffset",
+      defaultValue: 0,
+      public: true,
+    };
+    attributes.yoffset = {
+      createComponentOfType: "number",
+      createStateVariable: "yoffset",
+      defaultValue: 0,
+      public: true,
+    };
+    attributes.zoffset = {
+      createComponentOfType: "number",
+      createStateVariable: "zoffset",
+      defaultValue: 0,
+      public: true,
+    };
+    return attributes;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.independentComponentConstraints = {
+      returnDependencies: () => ({}),
+      definition: () => ({
+        setValue: { independentComponentConstraints: true },
+      }),
+    };
+
+    // Since state variable independentComponentConstraints is true,
+    // expect function applyComponentConstraint to be called with
+    // a single component value as the object, for example,  {x1: 13}
+
+    // use the convention of x1, x2, and x3 for variable names
+    // so that components can call constraints generically for n-dimensions
+    // use x,y,z for properties so that authors can use the more familar tag names
+
+    stateVariableDefinitions.applyComponentConstraint = {
+      returnDependencies: () => ({
+        dx: {
+          dependencyType: "stateVariable",
+          variableName: "dx",
+        },
+        dy: {
+          dependencyType: "stateVariable",
+          variableName: "dy",
+        },
+        dz: {
+          dependencyType: "stateVariable",
+          variableName: "dz",
+        },
+        xoffset: {
+          dependencyType: "stateVariable",
+          variableName: "xoffset",
+        },
+        yoffset: {
+          dependencyType: "stateVariable",
+          variableName: "yoffset",
+        },
+        zoffset: {
+          dependencyType: "stateVariable",
+          variableName: "zoffset",
+        },
+      }),
+      definition: ({ dependencyValues }) => ({
+        setValue: {
+          applyComponentConstraint: function (variables) {
+            // if given the value of x1, apply to constraint to x1
+            // and ignore any other arguments (which shouldn't be given)
+            if ("x1" in variables) {
+              let x1 = findFiniteNumericalValue(variables.x1);
+
+              // if found a non-numerical value, return no constraint
+              if (!Number.isFinite(x1)) {
+                return {};
+              }
+
+              let dx = dependencyValues.dx;
+              let xoffset = dependencyValues.xoffset;
+              let x1constrained =
+                Math.round((x1 - xoffset) / dx) * dx + xoffset;
+              if (Number.isFinite(x1constrained)) {
+                return {
+                  constrained: true,
+                  variables: { x1: x1constrained },
+                };
+              } else {
+                return {};
+              }
+            }
+
+            // if given the value of x2, apply to constraint to x2
+            // and ignore any other arguments (which shouldn't be given)
+            if ("x2" in variables) {
+              let x2 = findFiniteNumericalValue(variables.x2);
+              // if found a non-numerical value, return no constraint
+              if (!Number.isFinite(x2)) {
+                return {};
+              }
+
+              let dy = dependencyValues.dy;
+              let yoffset = dependencyValues.yoffset;
+              let x2constrained =
+                Math.round((x2 - yoffset) / dy) * dy + yoffset;
+              if (Number.isFinite(x2constrained)) {
+                return {
+                  constrained: true,
+                  variables: { x2: x2constrained },
+                };
+              } else {
+                return {};
+              }
+            }
+
+            // if given the value of x3, apply to constraint to x3
+            // and ignore any other arguments (which shouldn't be given)
+            if ("x3" in variables) {
+              let x3 = findFiniteNumericalValue(variables.x3);
+              // if found a non-numerical value, return no constraint
+              if (!Number.isFinite(x3)) {
+                return {};
+              }
+
+              let dz = dependencyValues.dz;
+              let zoffset = dependencyValues.zoffset;
+              let x3constrained =
+                Math.round((x3 - zoffset) / dz) * dz + zoffset;
+              if (Number.isFinite(x3constrained)) {
+                return {
+                  constrained: true,
+                  variables: { x3: x3constrained },
+                };
+              } else {
+                return {};
+              }
+            }
+
+            // if didn't get x1, x2, or x3 as argument, don't constrain anything
+            return {};
+          },
+        },
+      }),
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/ConstraintUnion.js

@@ -0,0 +1,119 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+import { findFiniteNumericalValue } from "../utils/math";
+import { applyConstraintFromComponentConstraints } from "../utils/constraints";
+
+export default class ConstraintUnion extends ConstraintComponent {
+  static componentType = "constraintUnion";
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "constraints",
+        componentTypes: ["_constraint"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.applyConstraint = {
+      returnDependencies: () => ({
+        constraintChildren: {
+          dependencyType: "child",
+          childGroups: ["constraints"],
+          variableNames: ["applyConstraint", "applyComponentConstraint"],
+          variablesOptional: true,
+        },
+      }),
+      definition: ({ dependencyValues }) => ({
+        setValue: {
+          applyConstraint: function (variables) {
+            let constraintResult;
+
+            if (dependencyValues.constraintChildren.length === 1) {
+              let constraintChild = dependencyValues.constraintChildren[0];
+              if (constraintChild.stateValues.applyConstraint) {
+                constraintResult =
+                  constraintChild.stateValues.applyConstraint(variables);
+              } else {
+                constraintResult = applyConstraintFromComponentConstraints(
+                  variables,
+                  constraintChild.stateValues.applyComponentConstraint,
+                );
+              }
+              return constraintResult;
+            }
+
+            let closestDistance2 = Infinity;
+            let closestResult = {};
+
+            let closestInd;
+
+            for (let [
+              ind,
+              constraintChild,
+            ] of dependencyValues.constraintChildren.entries()) {
+              if (constraintChild.stateValues.applyConstraint) {
+                constraintResult =
+                  constraintChild.stateValues.applyConstraint(variables);
+              } else {
+                constraintResult = applyConstraintFromComponentConstraints(
+                  variables,
+                  constraintChild.stateValues.applyComponentConstraint,
+                );
+              }
+
+              if (!constraintResult.constrained) {
+                continue;
+              }
+
+              let distance2 = 0;
+
+              for (let varname in constraintResult.variables) {
+                // since, for now, have a distance function only for numerical values,
+                // skip any constraints where don't have numerical values
+                let originalVar = findFiniteNumericalValue(variables[varname]);
+                let constrainedVar = findFiniteNumericalValue(
+                  constraintResult.variables[varname],
+                );
+
+                if (
+                  !Number.isFinite(originalVar) ||
+                  !Number.isFinite(constrainedVar)
+                ) {
+                  distance2 = Infinity;
+                  break;
+                }
+
+                distance2 += Math.pow(originalVar - constrainedVar, 2);
+              }
+
+              if (distance2 < closestDistance2) {
+                closestResult = constraintResult;
+                closestInd = ind + 1;
+                closestDistance2 = distance2;
+              }
+            }
+
+            if (closestInd === undefined) {
+              return {};
+            }
+
+            // prepend closestInd to constraintIndices;
+            if (closestResult.constraintIndices === undefined) {
+              closestResult.constraintIndices = [closestInd];
+            } else {
+              closestResult.constraintIndices = [
+                closestInd,
+                ...closestResult.constraintIndices,
+              ];
+            }
+            return closestResult;
+          },
+        },
+      }),
+    };
+    return stateVariableDefinitions;
+  }
+}