@doenet/doenetml 0.6.0-alpha1

package/src/Core/utils/naming.js

@@ -0,0 +1,45 @@
+import sha1 from "crypto-js/sha1";
+import Base64 from "crypto-js/enc-base64";
+
+let rePlus = /\+/g;
+let reSlash = /\//g;
+
+export function createUniqueName(componentType, longNameId) {
+  // use base64 encoding, but replace + with _ and / with -
+  // so that the name is a valid CSS identifier
+  let hashStringShortened = Base64.stringify(sha1(longNameId))
+    .slice(0, 10)
+    .replace(rePlus, "_")
+    .replace(reSlash, "-");
+
+  // console.log(`componentType: ${componentType}, longNameID: ${longNameId}, hashString: ${hashStringShortened}`)
+
+  return "__" + componentType + "_" + hashStringShortened;
+}
+
+export function getUniqueIdentifierFromBase(
+  uniqueIdentifierBase,
+  uniqueIdentifiersUsed,
+) {
+  let postfix = 1;
+  let uniqueIdentifier = uniqueIdentifierBase + postfix;
+
+  while (uniqueIdentifiersUsed.includes(uniqueIdentifier)) {
+    postfix += 1;
+    uniqueIdentifier = uniqueIdentifierBase + postfix;
+  }
+
+  uniqueIdentifiersUsed.push(uniqueIdentifier);
+
+  return uniqueIdentifier;
+}
+
+export function getNamespaceFromName(componentName) {
+  let lastSlash = componentName.lastIndexOf("/");
+  if (lastSlash === -1) {
+    throw Error(
+      `Encountered name ${componentName} that doesn't include a slash`,
+    );
+  }
+  return componentName.slice(0, lastSlash + 1);
+}

package/src/Core/utils/periodicSetEquality.js

@@ -0,0 +1,403 @@
+import me from "math-expressions";
+
+export default function periodicSetEquality(
+  expr,
+  other,
+  { min_elements_match = 3, match_partial = false } = {},
+) {
+  // expr must be a discrete infinite set
+  if (!is_periodic_set(expr)) return false;
+
+  // other must be a discrete infinite set or a list
+  if (is_periodic_set(other)) {
+    if (match_partial) {
+      let match1 = contained_in(expr.tree, other.tree, match_partial);
+      if (match1 === false) {
+        return 0;
+      }
+      let match2 = contained_in(other.tree, expr.tree, match_partial);
+      if (match2 === false) {
+        return 0;
+      }
+
+      if (match1 === true) {
+        if (match2 === true) {
+          return 1;
+        } else {
+          return match2;
+        }
+      } else if (match2 === true) {
+        return match1;
+      } else {
+        return Math.min(match1, match2);
+      }
+    } else {
+      return (
+        contained_in(expr.tree, other.tree, match_partial) &&
+        contained_in(other.tree, expr.tree, match_partial)
+      );
+    }
+  } else {
+    let operands = expr.tree.slice(1);
+
+    // implemented only if have just one tuple defining set
+    if (operands.length > 1) {
+      return false;
+    }
+
+    let offset = me.fromAst(operands[0][1]).evaluate_to_constant();
+    let period = me
+      .fromAst(["apply", "abs", operands[0][2]])
+      .evaluate_to_constant();
+
+    if (!Number.isFinite(offset) || !Number.isFinite(period)) {
+      return false;
+    }
+
+    let min_index = operands[0][3];
+    let max_index = operands[0][4];
+
+    // implemented only if min_index is -infinity and max_index is infinity
+    if (min_index !== -Infinity || max_index !== Infinity) {
+      return false;
+    }
+
+    // check if other is a list that begins and ends in 'ldots'
+    if (other.tree[0] !== "list") {
+      return false;
+    }
+
+    let number_list = other.tree.slice(1);
+
+    let n_ldots = 0;
+
+    if (number_list[0][0] === "ldots") {
+      n_ldots++;
+      number_list = number_list.slice(1);
+    } else if (!match_partial) {
+      return false;
+    }
+
+    if (number_list[number_list.length - 1][0] === "ldots") {
+      n_ldots++;
+      number_list = number_list.slice(0, number_list.length - 1);
+    } else if (!match_partial) {
+      return false;
+    }
+
+    let n_in_list = number_list.length;
+    if (n_in_list === 0) {
+      return false;
+    }
+
+    if (!match_partial && n_in_list < min_elements_match) {
+      return false;
+    }
+
+    number_list = number_list.map((x) => me.fromAst(x).evaluate_to_constant());
+
+    // use me.math.mod rather than % so it always non-negative
+    let offset_diff = me.math.mod(number_list[0] - offset, period);
+
+    if (!(me.math.min(offset_diff, period - offset_diff) < 1e-10 * period)) {
+      return false;
+    }
+
+    let n_matches = 1;
+
+    for (let i = 1; i < n_in_list; i++) {
+      if (
+        Math.abs(number_list[i] - number_list[i - 1] - period) <
+        1e-10 * period
+      ) {
+        n_matches++;
+      } else {
+        if (!match_partial) {
+          return false;
+        }
+        break;
+      }
+    }
+
+    if (
+      n_matches === n_in_list &&
+      n_ldots === 2 &&
+      n_in_list >= min_elements_match
+    ) {
+      return true;
+    }
+
+    let fraction_matched = n_matches / Math.max(n_in_list, min_elements_match);
+
+    // penalize if don't have dots
+    // max 80% without dots
+    fraction_matched *= (9 + n_ldots / 2) / 10;
+
+    return fraction_matched;
+
+    // let the_list = other_tree.slice(0,n_in_list+1);
+
+    // // get list of same size from
+    // let generated_list = sequence_from_discrete_infinite(expr, n_in_list);
+
+    // if(!generated_list)
+    //   return false;
+
+    // generated_list = ['list'].concat(generated_list);
+
+    // return full_equals(expr.context.from(generated_list), other.context.from(the_list));
+
+    // check if other is a list than ends in 'ldots'
+    // let other_tree = other.tree;
+
+    // if(other_tree[0] !== 'list')
+    //   return false;
+
+    // let n_in_list = other_tree.length-2;
+
+    // if(other_tree[n_in_list+1][0] !== 'ldots')
+    //   return false;
+
+    // if(n_in_list < min_elements_match)
+    //   return false;
+
+    // let the_list = other_tree.slice(0,n_in_list+1);
+
+    // // get list of same size from
+    // let generated_list = sequence_from_discrete_infinite(expr, n_in_list);
+
+    // if(!generated_list)
+    //   return false;
+
+    // generated_list = ['list'].concat(generated_list);
+
+    // return full_equals(expr.context.from(generated_list), other.context.from(the_list));
+  }
+}
+
+function is_periodic_set(expr) {
+  var tree = expr.tree;
+  if (!Array.isArray(tree)) return false;
+  if (tree[0] !== "periodic_set") return false;
+  var operands = tree.slice(1);
+
+  for (var v of operands) {
+    if (!Array.isArray(v)) return false;
+    if (v[0] !== "tuple") return false;
+    if (v.length !== 5) return false;
+  }
+
+  return true;
+}
+
+function contained_in(tree, i_set, match_partial) {
+  // true if tree is contained in the discrete infinite set i_set
+  // tree is either a discrete infinite set
+  // or a tuple of form [offset, period, min_index, max_index]
+
+  if (tree[0] === "periodic_set") {
+    if (match_partial) {
+      let num_matches = 0;
+      for (let piece of tree.slice(1)) {
+        let match = contained_in(piece, i_set, match_partial);
+        if (match === true) {
+          num_matches++;
+        } else if (match !== false) {
+          num_matches += match;
+        }
+      }
+
+      let num_pieces = tree.length - 1;
+
+      if (num_matches === num_pieces) {
+        return true;
+      } else if (num_matches === 0) {
+        return false;
+      } else {
+        return num_matches / num_pieces;
+      }
+    } else {
+      return tree.slice(1).every((v) => contained_in(v, i_set));
+    }
+  }
+
+  // tree is a tuple of the form [offset, period, min_index, max_index]
+
+  var offset0 = tree[1];
+  var period0 = tree[2];
+  var min_index = tree[3];
+  var max_index = tree[4];
+
+  // implemented only if min_index === -infinity and max_index === infinity
+  if (min_index !== -Infinity || max_index !== Infinity) return false;
+
+  // normalize to period 1
+  offset0 = me.fromAst(["/", offset0, period0]).evaluate_to_constant();
+
+  // if(!(typeof offset0 === 'number'))
+  //   return false;
+
+  var tuples = i_set.slice(1);
+
+  // data will be array of form [p, q, offset, period]
+  // where offset and period are normalized by period0
+  // and p/q is fraction form of period
+
+  var data = [];
+  for (let i = 0; i < tuples.length; i++) {
+    // implemented only if min_index === -infinity and max_index === infinity
+    let this_min_index = tuples[i][3];
+    let this_max_index = tuples[i][4];
+    if (this_min_index !== -Infinity || this_max_index !== Infinity)
+      return false;
+
+    let offset = me
+      .fromAst(["/", tuples[i][1], period0])
+      .evaluate_to_constant();
+    let period = me
+      .fromAst(["apply", "abs", ["/", tuples[i][2], period0]])
+      .evaluate_to_constant();
+
+    if (typeof period !== "number" || Number.isNaN(period)) return false;
+
+    let frac = me.math.fraction(period);
+    let p = frac.n;
+
+    if (p > 1000) {
+      return false;
+    }
+
+    let q = frac.d;
+    data.push([p, q, offset, period]);
+  }
+
+  // sort by p
+  data.sort();
+
+  // check any with period for which original period is a multiple
+  while (true) {
+    let p = data[0][0];
+    if (p !== 1) break;
+
+    let offset = data[0][2];
+    let period = data[0][3];
+
+    // offsets match, then we've covered all of tree
+    let offset_diff = me
+      .fromAst(["+", offset, ["-", offset0]])
+      .evaluate_to_constant();
+
+    if (Number.isFinite(offset_diff) && Number.isFinite(period)) {
+      // use me.math.mod rather than % so it always non-negative
+      offset_diff = me.math.mod(offset_diff, period);
+
+      if (me.math.min(offset_diff, period - offset_diff) < 1e-10 * period)
+        return true;
+    }
+    data.splice(0, 1); // remove first entry from data
+    if (data.length === 0) return false;
+  }
+
+  var all_ps = [...new Set(data.map((v) => v[0]))];
+
+  let max_fraction_covered = 0;
+
+  for (let base_p of all_ps) {
+    // find all ps where base_p is a multiple
+    let options = data
+      .map(function (v, i) {
+        let m = base_p / v[0];
+        if (Number.isInteger(m)) return [v[0], m, i];
+        else return undefined;
+      })
+      .filter((v) => v);
+
+    let covered = [];
+
+    for (let opt of options) {
+      let p = opt[0];
+      let m = opt[1];
+      let i = opt[2];
+      let offset = data[i][2];
+      let period = data[i][3];
+
+      for (let j = 0; j < p; j++) {
+        let offset_diff = me
+          .fromAst(["+", offset, ["-", ["+", offset0, j]]])
+          .evaluate_to_constant();
+
+        // use me.math.mod rather than % so it always non-negative
+        if (Number.isFinite(offset_diff) && Number.isFinite(period)) {
+          offset_diff = me.math.mod(offset_diff, period);
+
+          if (me.math.min(offset_diff, period - offset_diff) < 1e-10 * period) {
+            for (let k = 0; k < m; k++) {
+              covered[j + k * p] = true;
+            }
+
+            // check to see if covered all;
+            let covered_all = true;
+            for (let ind = 0; ind < base_p; ind++) {
+              if (!covered[ind]) {
+                covered_all = false;
+                break;
+              }
+            }
+
+            if (covered_all) return true;
+
+            break;
+          }
+        }
+      }
+    }
+
+    if (match_partial) {
+      let fraction_covered = 0;
+      for (let ind = 0; ind < base_p; ind++) {
+        if (covered[ind]) {
+          fraction_covered++;
+        }
+      }
+      fraction_covered /= base_p;
+
+      if (fraction_covered > max_fraction_covered) {
+        max_fraction_covered = fraction_covered;
+      }
+    }
+  }
+
+  if (match_partial && max_fraction_covered > 0) {
+    return max_fraction_covered;
+  }
+
+  return false;
+}
+
+function sequence_from_discrete_infinite(expr, n_elements) {
+  // assuming without checking that expr is discrete infinite set
+
+  var tree = expr.tree;
+  var operands = tree.slice(1);
+
+  // implemented only if have just one tuple defining set
+  if (operands.length > 1) return;
+
+  let offset = operands[0][1];
+  let period = operands[0][2];
+  let min_index = simplify.evaluate_numbers(operands[0][3]);
+  let max_index = operands[0][4];
+
+  // implemented only if min_index is defined and an integer and max_index is infinity
+  if (!Number.isInteger(min_index) || max_index !== Infinity) return;
+
+  let result = [];
+
+  for (let i = 0; i < n_elements; i++) {
+    result.push(
+      simplify.evaluate_numbers(["+", ["*", period, min_index + i], offset]),
+    );
+  }
+
+  return result;
+}

package/src/Core/utils/randomNumbers.js

@@ -0,0 +1,70 @@
+export function sampleFromRandomNumbers({
+  type,
+  numSamples,
+  standardDeviation,
+  mean,
+  to,
+  from,
+  step,
+  numDiscreteValues,
+  rng,
+}) {
+  if (type === "gaussian") {
+    if (!(standardDeviation >= 0) || !Number.isFinite(mean)) {
+      let message =
+        "Invalid mean (" +
+        mean +
+        ") or standard deviation (" +
+        standardDeviation +
+        ") for a gaussian random variable.";
+      console.warn(message);
+
+      return Array(numSamples).fill(NaN);
+    }
+
+    let sampledValues = [];
+
+    for (let i = 0; i < numSamples; i++) {
+      // Standard Normal variate using Box-Muller transform.
+      let u = 0,
+        v = 0;
+      while (u === 0) {
+        u = rng();
+      }
+      while (v === 0) {
+        v = rng();
+      }
+      let standardNormal =
+        Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+
+      // transform to correct parameters
+      sampledValues.push(mean + standardDeviation * standardNormal);
+    }
+
+    return sampledValues;
+  } else if (type === "uniform") {
+    let sampledValues = [];
+
+    let diff = to - from;
+
+    for (let i = 0; i < numSamples; i++) {
+      sampledValues.push(from + rng() * diff);
+    }
+
+    return sampledValues;
+  } else {
+    // discreteuniform
+    let sampledValues = [];
+
+    if (numDiscreteValues > 0) {
+      for (let i = 0; i < numSamples; i++) {
+        // random integer from 0 to numDiscreteValues-1
+        let ind = Math.floor(rng() * numDiscreteValues);
+
+        sampledValues.push(from + step * ind);
+      }
+    }
+
+    return sampledValues;
+  }
+}

package/src/Core/utils/retrieveMedia.js

@@ -0,0 +1,98 @@
+import axios from "axios";
+import { cidFromArrayBuffer } from "./cid";
+
+export async function retrieveMediaForCid(cid, mimeType) {
+  try {
+    return await retrieveMediaFromIPFS(cid);
+  } catch (e) {
+    // if have error from IPFS, fallback to retrieving from server
+  }
+
+  //Only if doenetML tag is not providing mimeType and not on IPFS
+  //look up in database
+  if (!mimeType) {
+    let { data } = await axios.get("/api/getMimeType.php", {
+      params: { cid: cid },
+    });
+    mimeType = data["mime-type"];
+  }
+
+  return retrieveMediaFromServer(cid, mimeType);
+}
+
+async function retrieveMediaFromIPFS(cid) {
+  let controller = new AbortController();
+  let signal = controller.signal;
+
+  // If the IPFS gateway cannot find the cid,
+  // it hangs for a long time before timing out.
+  // To avoid the long wait, abort the request after 1 second.
+  let timeoutId = setTimeout(() => {
+    controller.abort();
+  }, 1000);
+
+  try {
+    let response = await fetch(`https://${cid}.ipfs.dweb.link/`, { signal });
+
+    // if got a response, then we won't abort
+    clearTimeout(timeoutId);
+
+    if (response.ok) {
+      let mediaBlob = await response.blob();
+
+      let CidRetrieved = await cidFromArrayBuffer(
+        await mediaBlob.arrayBuffer(),
+      );
+
+      if (CidRetrieved === cid) {
+        let mediaURL = URL.createObjectURL(mediaBlob);
+        return { mediaBlob, mediaURL };
+      } else {
+        return Promise.reject(new Error("cid mismatch"));
+      }
+    } else {
+      return Promise.reject(new Error(`cid not found: ${cid}`));
+    }
+  } catch (e) {
+    return Promise.reject(new Error(`cid not found: ${cid}`));
+  }
+}
+
+async function retrieveMediaFromServer(cid, mimeType) {
+  try {
+    let extension = extensionFromMimeType(mimeType);
+
+    let response = await fetch(`/media/${cid}.${extension}`);
+
+    if (response.ok) {
+      let mediaBlob = await response.blob();
+
+      let CidRetrieved = await cidFromArrayBuffer(
+        await mediaBlob.arrayBuffer(),
+      );
+
+      if (CidRetrieved === cid) {
+        let mediaURL = URL.createObjectURL(mediaBlob);
+        return { mediaBlob, mediaURL };
+      } else {
+        return Promise.reject(new Error("cid mismatch"));
+      }
+    } else {
+      return Promise.reject(new Error(`cid not found: ${cid}`));
+    }
+  } catch (e) {
+    return Promise.reject(new Error(`cid not found: ${cid}`));
+  }
+}
+
+function extensionFromMimeType(mimeType) {
+  if (mimeType === "image/png") {
+    return "png";
+  } else if (mimeType === "image/jpeg") {
+    return "jpg";
+  } else if (mimeType === "text/csv") {
+    return "csv";
+  } else {
+    return "txt";
+  }
+}