Divide like terms powers

lib/ChangeTypes.js

@@ -42,8 +42,10 @@ module.exports = {
   // e.g. x + 2 + x^2 + x + 4 -> x^2 + (x + x) + (4 + 2)
   COLLECT_LIKE_TERMS: 'COLLECT_LIKE_TERMS',
 
-  // MULTIPLYING CONSTANT POWERS
-  // e.g. 10^2 * 10^3 -> 10^(2+3)
+  // MULTIPLYING/DIVIDING CONSTANT POWERS
+
+  // e.g. 10^2 * 10^3 -> 10^(3+2)
+  // e.g. 10^4 / 10^2 -> 10^(4-2)
   COLLECT_CONSTANT_EXPONENTS: 'COLLECT_CONSTANT_EXPONENTS',
 
   // ADDING POLYNOMIALS
@@ -67,6 +69,8 @@ module.exports = {
   MULTIPLY_COEFFICIENTS: 'MULTIPLY_COEFFICIENTS',
   // e.g. 2x * x -> 2x ^ 2
   MULTIPLY_POLYNOMIAL_TERMS: 'MULTIPLY_POLYNOMIAL_TERMS',
+  // e.g x^5 / x^3 -> x^2
+  DIVIDE_POLYNOMIAL_TERMS: 'DIVIDE_POLYNOMIAL_TERMS',
 
   // FRACTIONS
 

lib/checks/canDivideLikeTermConstantNodes.js

@@ -0,0 +1,24 @@
+const ConstantOrPowerTerm = require('../simplifyExpression/collectAndCombineSearch/ConstantOrConstantPower');
+const Node = require('../node');
+
+// Returns true if node is a division of constant power nodes
+// where you can combine their exponents, e.g. 10^4 / 10^2 can become 10^2
+// The node can be on the form c^n or c, as long is c is the same for all
+function canDivideLikeTermConstantNodes(node) {
+  if (!Node.Type.isOperator(node) || node.op !== '/') {
+    return false;
+  }
+  const args = node.args;
+  if (!args.every(n => ConstantOrPowerTerm.isConstantOrConstantPower(n))) {
+    return false;
+  }
+
+  const constantTermBaseList = args.map(n => ConstantOrPowerTerm.getBaseNode(n));
+  const firstTerm = constantTermBaseList[0];
+  const restTerms = constantTermBaseList.slice(1);
+  // they're considered like terms if they have the same base value
+  return restTerms.every(term => firstTerm.value === term.value);
+}
+
+module.exports = canDivideLikeTermConstantNodes;
+

lib/checks/canDivideLikeTermPolynomialNodes.js

@@ -0,0 +1,28 @@
+const Node = require('../node');
+
+// Returns true if the nodes are symbolic terms with the same symbol and no
+// coefficients.
+function canDivideLikeTermPolynomialNodes(node) {
+  if (!Node.Type.isOperator(node) || node.op !== '/') {
+    return false;
+  }
+  const args = node.args;
+  if (!args.every(n => Node.PolynomialTerm.isPolynomialTerm(n))) {
+    return false;
+  }
+  if (args.length === 1) {
+    return false;
+  }
+
+  const polynomialTermList = node.args.map(n => new Node.PolynomialTerm(n));
+  if (!polynomialTermList.every(polyTerm => !polyTerm.hasCoeff())) {
+    return false;
+  }
+
+  const firstTerm = polynomialTermList[0];
+  const restTerms = polynomialTermList.slice(1);
+  // they're considered like terms if they have the same symbol name
+  return restTerms.every(term => firstTerm.getSymbolName() === term.getSymbolName());
+}
+
+module.exports = canDivideLikeTermPolynomialNodes;

lib/checks/index.js

@@ -1,4 +1,6 @@
 const canAddLikeTermPolynomialNodes = require('./canAddLikeTermPolynomialNodes');
+const canDivideLikeTermConstantNodes = require('./canDivideLikeTermConstantNodes');
+const canDivideLikeTermPolynomialNodes = require('./canDivideLikeTermPolynomialNodes');
 const canMultiplyLikeTermConstantNodes = require('./canMultiplyLikeTermConstantNodes');
 const canMultiplyLikeTermPolynomialNodes = require('./canMultiplyLikeTermPolynomialNodes');
 const canRearrangeCoefficient = require('./canRearrangeCoefficient');
@@ -9,6 +11,8 @@ const resolvesToConstant = require('./resolvesToConstant');
 
 module.exports = {
   canAddLikeTermPolynomialNodes,
+  canDivideLikeTermConstantNodes,
+  canDivideLikeTermPolynomialNodes,
   canMultiplyLikeTermConstantNodes,
   canMultiplyLikeTermPolynomialNodes,
   canRearrangeCoefficient,

lib/simplifyExpression/collectAndCombineSearch/divideLikeTerms.js

@@ -0,0 +1,178 @@
+const arithmeticSearch = require('../arithmeticSearch');
+const checks = require('../../checks');
+const clone = require('../../util/clone');
+const ConstantOrConstantPower = require('./ConstantOrConstantPower');
+
+const ChangeTypes = require('../../ChangeTypes');
+const Node = require('../../node');
+
+// Divides a list of nodes that are polynomial like terms or constants with same base.
+// Returns a node.
+// The nodes should *not* have coefficients.
+function divideLikeTerms(node, polynomialOnly = false) {
+  if (!Node.Type.isOperator(node)) {
+    return Node.Status.noChange(node);
+  }
+  let status;
+
+  if (!polynomialOnly && !checks.canDivideLikeTermConstantNodes(node)) {
+    status = arithmeticSearch(node);
+    if (status.hasChanged()) {
+      status.changeType = ChangeTypes.SIMPLIFY_FRACTION;
+      return status;
+    }
+  }
+
+  status = dividePolynomialTerms(node);
+  if (status.hasChanged()) {
+    status.changeType = ChangeTypes.SIMPLIFY_FRACTION;
+    return status;
+  }
+
+  return Node.Status.noChange(node);
+}
+
+function dividePolynomialTerms(node) {
+  if (!checks.canDivideLikeTermPolynomialNodes(node) &&
+      !checks.canDivideLikeTermConstantNodes(node)) {
+    return Node.Status.noChange(node);
+  }
+
+  const substeps = [];
+  let newNode = clone(node);
+
+  // STEP 1: If any term has no exponent, make it have exponent 1
+  // e.g. x -> x^1 (this is for pedagogy reasons)
+  // (this step only happens under certain conditions and later steps might
+  // happen even if step 1 does not)
+  let status = addOneExponent(newNode);
+  if (status.hasChanged()) {
+    substeps.push(status);
+    newNode = Node.Status.resetChangeGroups(status.newNode);
+  }
+
+  // STEP 2: collect exponents to a single exponent difference
+  // e.g. x^1 / x^3 -> x^(1 + -3)
+  if (checks.canDivideLikeTermConstantNodes(node)) {
+    status = collectConstantExponents(newNode);
+  }
+  else {
+    status = collectPolynomialExponents(newNode);
+  }
+  substeps.push(status);
+  newNode = Node.Status.resetChangeGroups(status.newNode);
+
+  // STEP 3: calculate difference of exponents.
+  // NOTE: This might not be a step if the exponents aren't all constants,
+  // but this case isn't that common and can be caught in other steps.
+  // e.g. x^(2-4-z)
+  // TODO: handle fractions, combining and collecting like terms, etc, here
+  const exponentDiff = newNode.args[1].content;
+  const diffStatus = arithmeticSearch(exponentDiff);
+  if (diffStatus.hasChanged()) {
+    status = Node.Status.childChanged(newNode, diffStatus, 1);
+    substeps.push(status);
+    newNode = Node.Status.resetChangeGroups(status.newNode);
+  }
+
+  if (substeps.length === 1) { // possible if only step 2 happens
+    return substeps[0];
+  }
+  else {
+    return Node.Status.nodeChanged(
+      ChangeTypes.DIVIDE_POLYNOMIAL_TERMS,
+      node, newNode, true, substeps);
+  }
+}
+
+// Given a product of polynomial terms, changes any term with no exponent
+// into a term with an explicit exponent of 1. This is for pedagogy, and
+// makes the adding coefficients step clearer.
+// e.g. x^2 / x -> x^2 / x^1
+// Returns a Node.Status object.
+function addOneExponent(node) {
+  const newNode = clone(node);
+  let change = false;
+
+  let changeGroup = 1;
+  if (checks.canDivideLikeTermConstantNodes(node)) {
+    newNode.args.forEach((child, i) => {
+      if (Node.Type.isConstant(child)) {
+        const base = ConstantOrConstantPower.getBaseNode(child);
+        const exponent = Node.Creator.constant(1);
+        newNode.args[i] = Node.Creator.operator('^', [base, exponent]);
+
+        newNode.args[i].changeGroup = changeGroup;
+        node.args[i].changeGroup = changeGroup; // note that this is the "oldNode"
+
+        change = true;
+        changeGroup++;
+      }
+    });
+  }
+  else {
+    newNode.args.forEach((child, i) => {
+      const polyTerm = new Node.PolynomialTerm(child);
+      if (!polyTerm.getExponentNode()) {
+        newNode.args[i] = Node.Creator.polynomialTerm(
+          polyTerm.getSymbolNode(),
+          Node.Creator.constant(1),
+          polyTerm.getCoeffNode());
+
+        newNode.args[i].changeGroup = changeGroup;
+        node.args[i].changeGroup = changeGroup; // note that this is the "oldNode"
+
+        change = true;
+        changeGroup++;
+      }
+    });
+  }
+
+  if (change) {
+    return Node.Status.nodeChanged(
+      ChangeTypes.ADD_EXPONENT_OF_ONE, node, newNode, false);
+  }
+  else {
+    return Node.Status.noChange(node);
+  }
+}
+
+// Given a division of constant terms, groups the exponents into a difference
+// e.g. 10^5 / 10^3 -> 10^(5 - 3)
+// Returns a Node.Status object.
+function collectConstantExponents(node) {
+
+  // If we're dividing constant nodes together, they all share the same
+  // base. Get that from the first node.
+  const baseNode = ConstantOrConstantPower.getBaseNode(node.args[0]);
+
+  // The new exponent will be a difference of exponents (an operation, wrapped in
+  // parens) e.g. 10^(5-3)
+  const exponentNodeList = node.args.map(ConstantOrConstantPower.getExponentNode);
+  const newExponent = Node.Creator.parenthesis(
+    Node.Creator.operator('-', exponentNodeList));
+  const newNode = Node.Creator.operator('^', [baseNode, newExponent]);
+  return Node.Status.nodeChanged(
+    ChangeTypes.COLLECT_CONSTANT_EXPONENTS, node, newNode);
+}
+// Given a division of polynomial terms, groups the exponents into a difference
+// e.g. x^5 / x^3 -> x^(5 - 3)
+// Returns a Node.Status object.
+function collectPolynomialExponents(node) {
+  const polynomialTermList = node.args.map(n => new Node.PolynomialTerm(n));
+
+  // If we're dividing polynomial nodes together, they all share the same
+  // symbol. Get that from the first node.
+  const symbolNode = polynomialTermList[0].getSymbolNode();
+
+  // The new exponent will be a difference of exponents (an operation, wrapped in
+  // parens) e.g. x^(5-3)
+  const exponentNodeList = polynomialTermList.map(p => p.getExponentNode(true));
+  const newExponent = Node.Creator.parenthesis(
+    Node.Creator.operator('-', exponentNodeList));
+  const newNode = Node.Creator.polynomialTerm(symbolNode, newExponent, null);
+  return Node.Status.nodeChanged(
+    ChangeTypes.COLLECT_POLYNOMIAL_EXPONENTS, node, newNode);
+}
+
+module.exports = divideLikeTerms;

lib/simplifyExpression/collectAndCombineSearch/index.js

@@ -3,6 +3,7 @@
 const addLikeTerms = require('./addLikeTerms');
 const checks = require('../../checks');
 const clone = require('../../util/clone');
+const divideLikeTerms = require('./divideLikeTerms');
 const multiplyLikeTerms = require('./multiplyLikeTerms');
 
 const ChangeTypes = require('../../ChangeTypes');
@@ -12,6 +13,7 @@ const TreeSearch = require('../../TreeSearch');
 
 const termCollectorFunctions = {
   '+': addLikeTerms,
+  '/': divideLikeTerms,
   '*': multiplyLikeTerms
 };
 
@@ -48,6 +50,12 @@ function collectAndCombineLikeTerms(node) {
     // e.g. x * x^2 * x => ... => x^4
     return multiplyLikeTerms(node, true);
   }
+  else if (node.op === '/') {
+    // we might also be able to just combine like terms
+    // e.g 10^6 / 10^3 => ... => 10^3
+    // e.g x^5 / x^2 => ... => x^3
+    return divideLikeTerms(node, true);
+  }
   else {
     return Node.Status.noChange(node);
   }

test/canDivideLikeTermConstantNodes.test.js

@@ -0,0 +1,18 @@
+const canDivideLikeTermConstantNodes = require('../lib/checks/canDivideLikeTermConstantNodes');
+
+
+const TestUtil = require('./TestUtil');
+
+function testCanBeDividedConstants(expr, multipliable) {
+  TestUtil.testBooleanFunction(canDivideLikeTermConstantNodes, expr, multipliable);
+}
+
+describe('can divide like term constants', () => {
+  const tests = [
+    ['3^2 / 3^5', true],
+    ['2^3 / 3^2', false],
+    ['10^3 / 10^2', true],
+    ['10^6 / 10^4', true]
+  ];
+  tests.forEach(t => testCanBeDividedConstants(t[0], t[1]));
+});

test/canDivideLikeTermPolynomialNodes.test.js

@@ -0,0 +1,17 @@
+const canDivideLikeTermPolynomialNodes = require('../lib/checks/canDivideLikeTermPolynomialNodes');
+
+const TestUtil = require('./TestUtil');
+
+function testCanBeDivided(expr, multipliable) {
+  TestUtil.testBooleanFunction(canDivideLikeTermPolynomialNodes, expr, multipliable);
+}
+
+describe('can divide like term polynomials', () => {
+  const tests = [
+    ['x^2 / x', true],
+    ['3x^2 / x ', false],
+    ['y^3 / y^2', true],
+    ['x^8 / x^5', true]
+  ];
+  tests.forEach(t => testCanBeDivided(t[0], t[1]));
+});

test/simplifyExpression/collectAndCombineSearch/collectAndCombineSearch.test.js

@@ -32,6 +32,22 @@ describe('combinePolynomialTerms multiplication', function() {
   tests.forEach(t => testCollectAndCombineSubsteps(t[0], t[1], t[2]));
 });
 
+describe('combinePolynomialPowerTerms division', function() {
+  const tests = [
+    ['x^2 / x',
+      ['x^2 / (x^1)',
+        'x^(2 - 1)',
+        'x^1'],
+    ],
+    ['y / y^3',
+      ['y^1 / (y^3)',
+        'y^(1 - 3)',
+        'y^-2'],
+    ],
+  ];
+  tests.forEach(t => testCollectAndCombineSubsteps(t[0], t[1], t[2]));
+});
+
 describe('combinePolynomialTerms addition', function() {
   const tests = [
     ['x+x',
@@ -88,3 +104,15 @@ describe('collect and multiply like terms', function() {
   ];
   tests.forEach(t => testSimpleCollectAndCombineSearch(t[0], t[1]));
 });
+
+describe('collect and divide multiply like terms', function() {
+  const tests = [
+    ['10^5 / 10^2', '10^3'],
+    ['2^4 / 2^2', '2^2'],
+    ['2^3 / 2^4', '2^-1'],
+    ['x^3 / x^4', 'x^-1'],
+    ['y^5 / y^2', 'y^3'],
+    ['z^4 / z^2', 'z^2'],
+  ];
+  tests.forEach(t => testSimpleCollectAndCombineSearch(t[0], t[1]));
+});