@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/Integer.js

@@ -0,0 +1,81 @@
+import NumberComponent from "./Number";
+import me from "math-expressions";
+import { renameStateVariable } from "../utils/stateVariables";
+import { textToAst } from "../utils/math";
+
+export default class Integer extends NumberComponent {
+  static componentType = "integer";
+  static rendererType = "number";
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    renameStateVariable({
+      stateVariableDefinitions,
+      oldName: "value",
+      newName: "valuePreRound",
+    });
+
+    stateVariableDefinitions.value = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "number",
+      },
+      returnDependencies: () => ({
+        valuePreRound: {
+          dependencyType: "stateVariable",
+          variableName: "valuePreRound",
+        },
+      }),
+      set: function (value) {
+        // this function is called when
+        // - definition is overridden by a copy prop
+        // - when processing new state variable values
+        //   (which could be from outside sources)
+        if (value === null) {
+          return NaN;
+        }
+        let number = Number(value);
+        if (Number.isNaN(number)) {
+          try {
+            number = me
+              .fromAst(textToAst.convert(value))
+              .evaluate_to_constant();
+            if (number === null) {
+              number = NaN;
+            }
+          } catch (e) {
+            number = NaN;
+          }
+        }
+        return Math.round(number);
+      },
+      definition({ dependencyValues }) {
+        return {
+          setValue: { value: Math.round(dependencyValues.valuePreRound) },
+        };
+      },
+      inverseDefinition({ desiredStateVariableValues }) {
+        let desiredValue = desiredStateVariableValues.value;
+        if (desiredValue instanceof me.class) {
+          desiredValue = desiredValue.evaluate_to_constant();
+        } else {
+          desiredValue = Number(desiredValue);
+        }
+        desiredValue = Math.round(desiredValue);
+
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "valuePreRound",
+              desiredValue,
+            },
+          ],
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/Intersection.js

@@ -0,0 +1,328 @@
+import CompositeComponent from "./abstract/CompositeComponent";
+import { postProcessCopy } from "../utils/copy";
+import me from "math-expressions";
+import { processAssignNames } from "../utils/serializedStateProcessing";
+
+export default class Intersection extends CompositeComponent {
+  static componentType = "intersection";
+
+  static assignNamesToReplacements = true;
+
+  static stateVariableToEvaluateAfterReplacements = "readyToExpandWhenResolved";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.assignNamesSkip = {
+      createPrimitiveOfType: "number",
+    };
+
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "lines",
+        componentTypes: ["line"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.lineChildren = {
+      returnDependencies: () => ({
+        lineChildren: {
+          dependencyType: "child",
+          childGroups: ["lines"],
+          variableNames: [
+            "numericalCoeff0",
+            "numericalCoeffvar1",
+            "numericalCoeffvar2",
+            "numDimensions",
+          ],
+        },
+      }),
+      definition: ({ dependencyValues }) => ({
+        setValue: {
+          lineChildren: dependencyValues.lineChildren,
+        },
+      }),
+    };
+
+    stateVariableDefinitions.readyToExpandWhenResolved = {
+      returnDependencies: () => ({
+        lineChildren: {
+          dependencyType: "stateVariable",
+          variableName: "lineChildren",
+        },
+      }),
+      markStale: () => ({ updateReplacements: true }),
+      definition: function () {
+        return { setValue: { readyToExpandWhenResolved: true } };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  static async createSerializedReplacements({
+    component,
+    components,
+    componentInfoObjects,
+  }) {
+    let lineChildren = await component.stateValues.lineChildren;
+    let numberLineChildren = lineChildren.length;
+
+    if (numberLineChildren === 0) {
+      return { replacements: [] };
+    }
+
+    // intersection of one object is the object itself
+    if (numberLineChildren === 1) {
+      let childName = lineChildren[0].componentName;
+      let serializedChild = await components[childName].serialize({
+        sourceAttributesToIgnore: ["isResponse"],
+      });
+      if (!serializedChild.state) {
+        serializedChild.state = {};
+      }
+      serializedChild.state.draggable = false;
+      serializedChild.state.fixed = true;
+
+      let serializedReplacements = postProcessCopy({
+        serializedComponents: [serializedChild],
+        componentName: component.componentName,
+      });
+
+      let newNamespace = component.attributes.newNamespace?.primitive;
+
+      let processResult = processAssignNames({
+        assignNames: component.doenetAttributes.assignNames,
+        serializedComponents: serializedReplacements,
+        parentName: component.componentName,
+        parentCreatesNewNamespace: newNamespace,
+        componentInfoObjects,
+      });
+
+      serializedReplacements = processResult.serializedComponents;
+
+      return { replacements: serializedReplacements };
+    }
+
+    if (numberLineChildren > 2) {
+      console.warn(
+        "Haven't implemented intersection for more than two objects",
+      );
+      return { replacements: [] };
+    }
+
+    // for now, have only implemented for two lines
+    // in 2D with constant coefficients
+    let line1 = lineChildren[0];
+    let line2 = lineChildren[1];
+
+    if (
+      line1.stateValues.numDimensions !== 2 ||
+      line2.stateValues.numDimensions !== 2
+    ) {
+      console.log("Intersection of lines implemented only in 2D");
+      return { replacements: [] };
+    }
+
+    // only implement for constant coefficients
+    let a1 = line1.stateValues.numericalCoeffvar1;
+    let b1 = line1.stateValues.numericalCoeffvar2;
+    let c1 = line1.stateValues.numericalCoeff0;
+    let a2 = line2.stateValues.numericalCoeffvar1;
+    let b2 = line2.stateValues.numericalCoeffvar2;
+    let c2 = line2.stateValues.numericalCoeff0;
+
+    if (
+      !(
+        Number.isFinite(a1) &&
+        Number.isFinite(b1) &&
+        Number.isFinite(c1) &&
+        Number.isFinite(a2) &&
+        Number.isFinite(b2) &&
+        Number.isFinite(c2)
+      )
+    ) {
+      console.log(
+        "Intersection of lines implemented only for constant coefficients",
+      );
+      return { replacements: [] };
+    }
+
+    let d = a1 * b2 - a2 * b1;
+
+    if (Math.abs(d) < 1e-14) {
+      if (Math.abs(c2 * a1 - c1 * a2) > 1e-14) {
+        // parallel lines
+        return { replacements: [] };
+      } else if (
+        (a1 === 0 && b1 === 0 && c1 === 0) ||
+        (a2 === 0 && b2 === 0 && c2 === 0)
+      ) {
+        // at least one line not defined
+        return { replacements: [] };
+      } else {
+        // two identical lines, return first line
+        let childName = lineChildren[0].componentName;
+        let serializedChild = await components[childName].serialize({
+          sourceAttributesToIgnore: ["isResponse"],
+        });
+        if (!serializedChild.state) {
+          serializedChild.state = {};
+        }
+        serializedChild.state.draggable = false;
+        serializedChild.state.fixed = true;
+
+        let serializedReplacements = postProcessCopy({
+          serializedComponents: [serializedChild],
+          componentName: component.componentName,
+        });
+
+        let newNamespace = component.attributes.newNamespace?.primitive;
+
+        let processResult = processAssignNames({
+          assignNames: component.doenetAttributes.assignNames,
+          serializedComponents: serializedReplacements,
+          parentName: component.componentName,
+          parentCreatesNewNamespace: newNamespace,
+          componentInfoObjects,
+        });
+
+        serializedReplacements = processResult.serializedComponents;
+
+        return { replacements: serializedReplacements };
+      }
+    }
+
+    // two intersecting lines, return point
+    let x = (c2 * b1 - c1 * b2) / d;
+    let y = (c1 * a2 - c2 * a1) / d;
+    let coords = me.fromAst(["vector", x, y]);
+
+    let serializedReplacements = [
+      {
+        componentType: "point",
+        state: { coords, draggable: false, fixed: true },
+      },
+    ];
+
+    let newNamespace = component.attributes.newNamespace?.primitive;
+
+    let processResult = processAssignNames({
+      assignNames: component.doenetAttributes.assignNames,
+      serializedComponents: serializedReplacements,
+      parentName: component.componentName,
+      parentCreatesNewNamespace: newNamespace,
+      componentInfoObjects,
+    });
+
+    serializedReplacements = processResult.serializedComponents;
+
+    return { replacements: serializedReplacements };
+
+    // TODO: would it be preferable to send an xs attribute
+    // rather than a coords state variable?
+    // If so, need to change state variable change is update replacements
+
+    // return {
+    //   replacements: [{
+    //     componentType: "point",
+    //     attributes: {
+    //       xs: {
+    //         component: {
+    //           componentType: "mathList",
+    //           children: [{
+    //             componentType: "math",
+    //             state: { value: me.fromAst(x) }
+    //           }, {
+    //             componentType: "math",
+    //             state: { value: me.fromAst(y) }
+    //           }]
+    //         }
+    //       }
+    //     },
+    //     state: { draggable: false, fixed: true },
+    //   }]
+    // };
+  }
+
+  static async calculateReplacementChanges({
+    component,
+    components,
+    componentInfoObjects,
+  }) {
+    let replacementChanges = [];
+
+    let serializedIntersections = (
+      await this.createSerializedReplacements({
+        component,
+        components,
+        componentInfoObjects,
+      })
+    ).replacements;
+
+    let nNewIntersections = serializedIntersections.length;
+
+    let recreateReplacements = true;
+
+    if (nNewIntersections === component.replacements.length) {
+      recreateReplacements = false;
+
+      for (let ind = 0; ind < nNewIntersections; ind++) {
+        if (
+          serializedIntersections[ind].componentType !==
+          component.replacements[ind].componentType
+        ) {
+          // found a different type of replacement, so recreate from scratch
+          recreateReplacements = true;
+          break;
+        }
+        // only need to change state variables
+
+        if (serializedIntersections[ind].state === undefined) {
+          console.warn(
+            "No state by which to update intersection component, so recreating",
+          );
+          recreateReplacements = true;
+          break;
+        }
+        if (serializedIntersections[ind].componentType !== "point") {
+          console.warn(
+            `Have not implemented state changes for an intersection that results in a  ${serializedIntersections[ind].componentType}, so recreating`,
+          );
+          recreateReplacements = true;
+          break;
+        }
+
+        let replacementInstruction = {
+          changeType: "updateStateVariables",
+          component: component.replacements[ind],
+          stateChanges: { coords: serializedIntersections[ind].state.coords },
+        };
+        replacementChanges.push(replacementInstruction);
+      }
+    }
+
+    if (recreateReplacements === false) {
+      return replacementChanges;
+    }
+
+    // replace with new intersection
+    let replacementInstruction = {
+      changeType: "add",
+      changeTopLevelReplacements: true,
+      firstReplacementInd: 0,
+      numberReplacementsToReplace: component.replacements.length,
+      serializedReplacements: serializedIntersections,
+    };
+
+    return [replacementInstruction];
+  }
+}

package/src/Core/components/Interval.js

@@ -0,0 +1,29 @@
+import MathComponent from "./Math";
+
+export default class Interval extends MathComponent {
+  static componentType = "interval";
+  static rendererType = "math";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    delete attributes.createIntervals;
+    return attributes;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.createIntervals = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "boolean",
+      },
+      returnDependencies: () => ({}),
+      definition: () => ({ setValue: { createIntervals: true } }),
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  // TODO: do we want to give warnings or errors if value is not in form of an interval?
+}