diff --git a/lib/ChangeTypes.js b/lib/ChangeTypes.js index e0ceaf34..6a48efb0 100644 --- a/lib/ChangeTypes.js +++ b/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 diff --git a/lib/checks/canDivideLikeTermConstantNodes.js b/lib/checks/canDivideLikeTermConstantNodes.js new file mode 100644 index 00000000..f38f30d2 --- /dev/null +++ b/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; + diff --git a/lib/checks/canDivideLikeTermPolynomialNodes.js b/lib/checks/canDivideLikeTermPolynomialNodes.js new file mode 100644 index 00000000..c77b5631 --- /dev/null +++ b/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; diff --git a/lib/checks/index.js b/lib/checks/index.js index ddf93f61..99d0c39c 100644 --- a/lib/checks/index.js +++ b/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, diff --git a/lib/simplifyExpression/collectAndCombineSearch/divideLikeTerms.js b/lib/simplifyExpression/collectAndCombineSearch/divideLikeTerms.js new file mode 100644 index 00000000..e041cfff --- /dev/null +++ b/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; diff --git a/lib/simplifyExpression/collectAndCombineSearch/index.js b/lib/simplifyExpression/collectAndCombineSearch/index.js index a8cdd541..123d5f1d 100644 --- a/lib/simplifyExpression/collectAndCombineSearch/index.js +++ b/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); } diff --git a/test/canDivideLikeTermConstantNodes.test.js b/test/canDivideLikeTermConstantNodes.test.js new file mode 100644 index 00000000..3ec2a7f5 --- /dev/null +++ b/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])); +}); diff --git a/test/canDivideLikeTermPolynomialNodes.test.js b/test/canDivideLikeTermPolynomialNodes.test.js new file mode 100644 index 00000000..33e31f66 --- /dev/null +++ b/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])); +}); diff --git a/test/simplifyExpression/collectAndCombineSearch/collectAndCombineSearch.test.js b/test/simplifyExpression/collectAndCombineSearch/collectAndCombineSearch.test.js index df79cb48..eb104857 100644 --- a/test/simplifyExpression/collectAndCombineSearch/collectAndCombineSearch.test.js +++ b/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])); +});