mathsteps-experimental-fork/dist/cjs/lib/simplifyExpression/mscNormalizeNodeFunctions.js

Step by step math solutions. Experimental Fork

'use strict';

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

const config = require('../config.js');
const myNodeToString = require('../newServices/nodeServices/myNodeToString.js');
const parseText = require('../newServices/nodeServices/parseText.js');
const cleanString = require('../util/cleanString.js');
const regex = require('../util/regex.js');
const impureFunctionsAny_generated = require('../../node_modules/.pnpm/mathjs@13.1.1/node_modules/mathjs/lib/esm/entry/impureFunctionsAny.generated.js');

function convertNumParVarDivNumToNumVarDivNum(expressionOrNode) {
  const coreFn = () => {
    const mathTree = typeof expressionOrNode === "string" ? parseText.parseText(expressionOrNode) : parseText.parseText(myNodeToString.myNodeToString(expressionOrNode));
    function traverse(node) {
      if (config.isOperatorNode(node)) {
        const opNode = node;
        const transformedArgs = opNode.args.map(traverse);
        const newNode = new impureFunctionsAny_generated.OperatorNode(opNode.op, opNode.fn, transformedArgs);
        if (newNode.op === "*") {
          const [left, right] = newNode.args;
          if (config.isConstantNode(left) && config.isOperatorNode(right) && right.op === "/") {
            const rightOpNode = right;
            const [numerator, denominator] = rightOpNode.args;
            if (config.isSymbolNode(numerator) && config.isConstantNode(denominator)) {
              const newNumerator = new impureFunctionsAny_generated.OperatorNode("*", "multiply", [left, numerator]);
              const newNumeratorWithParens = new impureFunctionsAny_generated.ParenthesisNode(newNumerator);
              const newDenominator = denominator;
              const transformedNode = new impureFunctionsAny_generated.OperatorNode("/", "divide", [newNumeratorWithParens, newDenominator]);
              return transformedNode;
            }
          }
          if (config.isOperatorNode(left) && left.op === "/" && config.isConstantNode(right)) {
            const leftOpNode = left;
            const [numerator, denominator] = leftOpNode.args;
            if (config.isSymbolNode(numerator) && config.isConstantNode(denominator)) {
              const newNumerator = new impureFunctionsAny_generated.OperatorNode("*", "multiply", [right, numerator]);
              const newNumeratorWithParens = new impureFunctionsAny_generated.ParenthesisNode(newNumerator);
              const newDenominator = denominator;
              const transformedNode = new impureFunctionsAny_generated.OperatorNode("/", "divide", [newNumeratorWithParens, newDenominator]);
              return transformedNode;
            }
          }
        }
        return newNode;
      } else {
        return node;
      }
    }
    return traverse(mathTree);
  };
  return parseText.parseText(myNodeToString.myNodeToString(coreFn()));
}
function convertAllSimpleFractionsToDecimals(node) {
  const convertFractions = (node2) => {
    if (config.isOperatorNode(node2) && node2.op === "/" && node2.args.length === 2 && config.isConstantNode(node2.args[0]) && config.isConstantNode(node2.args[1])) {
      const leftValue = node2.args[0].value;
      const rightValue = node2.args[1].value;
      if (leftValue % rightValue === 0) {
        return node2;
      }
      return new config.ConstantNode(leftValue / rightValue);
    }
    if (config.isOperatorNode(node2) && node2.args) {
      node2.args = node2.args.map(convertFractions);
    }
    return node2;
  };
  return convertFractions(node);
}
function convertAll1xToX(node) {
  const convert1x = (node2) => {
    if (config.isOperatorNode(node2) && node2.op === "*" && node2.args.length === 2 && config.isConstantNode(node2.args[0]) && config.isSymbolNode(node2.args[1]) && node2.args[0].toString() === "1") {
      return node2.args[1];
    }
    if (config.isOperatorNode(node2) && node2.args) {
      node2.args = node2.args.map(convert1x);
    }
    return node2;
  };
  return convert1x(node);
}
function makePlusMinusMinusAndReturnString(node) {
  const nodeStr = typeof node === "string" ? cleanString.cleanString(node) : myNodeToString.myNodeToString(node);
  const numberRG = "\\b\\d+(?:\\.\\d+)?[a-z]?\\b";
  const regexExp = regex.makeExtendedRegExp(
    String.raw`
  \+\-          # +-
  (             #  number / number match group
    ${numberRG}
    \/
    ${numberRG}
  )
  `,
    "gi"
  );
  return nodeStr.replace(regexExp, "+(-$1)").replaceAll("+-", "-");
}
function normalizeNegativesAndFractions(node) {
  const handleNegatives = (node2) => {
    if (config.isOperatorNode(node2) && node2.op === "/" && config.isConstantNode(node2.args[0]) && node2.args[0].value < 0) {
      const positiveNumerator = new config.ConstantNode(Math.abs(node2.args[0].value));
      const denominator = node2.args[1];
      return new impureFunctionsAny_generated.OperatorNode("-", "unaryMinus", [
        new impureFunctionsAny_generated.OperatorNode("/", "divide", [positiveNumerator, denominator])
      ]);
    }
    if (config.isOperatorNode(node2) && node2.args) {
      node2.args = node2.args.map(handleNegatives);
    }
    return node2;
  };
  return handleNegatives(node);
}

exports.convertAll1xToX = convertAll1xToX;
exports.convertAllSimpleFractionsToDecimals = convertAllSimpleFractionsToDecimals;
exports.convertNumParVarDivNumToNumVarDivNum = convertNumParVarDivNumToNumVarDivNum;
exports.makePlusMinusMinusAndReturnString = makePlusMinusMinusAndReturnString;
exports.normalizeNegativesAndFractions = normalizeNegativesAndFractions;