Multiplying polynomials

lib/rules.js

@@ -1,9 +1,10 @@
 import {parse, print} from 'math-parser'
 import evaluate from 'math-evaluator'
-import {query} from 'math-nodes'
-import {traverse} from 'math-traverse'
+import {build, query} from 'math-nodes'
+import {traverse, replace} from 'math-traverse'
 
-import {defineRule, definePatternRule} from './matcher'
+import {defineRule, definePatternRule, canApplyRule, applyRule} from './matcher'
+import {isPolynomialTerm, getCoefficient, getVariableFactors, getCoefficientsAndConstants} from './rules/collect-like-terms.js'
 import {clone, getRanges} from './utils'
 
 const defineRuleString = (matchPattern, rewritePattern, constraints) => {
@@ -151,7 +152,7 @@ export const SIMPLIFY_SIGNS = defineRuleString('#a / -#b', '-#a / #b')
 
 // ADDING FRACTIONS
 
-export const ADD_NUMERATORS =
+export const COMBINE_NUMERATORS =
     defineRuleString('#a_0 / #b + ...', '(#a_0 + ...) / #b')
 
 export const COMMON_DENOMINATOR =
@@ -184,9 +185,60 @@ export const ABSOLUTE_VALUE = defineRuleString('|-#a|', '#a')
 
 // MULTIPLYING POLYNOMIALS
 
+// e.g. 6x y z -> 6 (x^1y^1z^1) (where x, y, z are
+// separate identifiers)
+
+export const ADD_EXPONENT_OF_ONE_HELPER = defineRule(
+    (node) => {
+        const hasConstantVariable = query.isMul(node) && node.args.some(query.isIdentifier)
+
+        return (hasConstantVariable) ? {node} : null
+    },
+
+    (node) => {
+        const result = build.applyNode(
+            'mul',
+            node.args.map(arg => {
+                if (query.isIdentifier(arg)){
+                    return build.applyNode('pow', [arg, build.numberNode(1)])
+                }
+                return arg
+            }), {implicit: node.implicit}
+        )
+        return result
+    }
+)
+
 // e.g. x^2 * x -> x^2 * x^1
-// export const ADD_EXPONENT_OF_ONE = ...
+export const ADD_EXPONENT_OF_ONE = defineRule(
+    (node) => {
+        let isMulOfPolynomials = false
+
+        if (query.isMul(node)) {
+            const {constants, coefficientMap} = getCoefficientsAndConstants(node)
+            isMulOfPolynomials = Object.keys(coefficientMap).length > 1
+                || Object.keys(coefficientMap)
+                .some(key => coefficientMap[key].length > 1)
+        }
+
+        return (isMulOfPolynomials && !node.implicit) ? {node} : null
+    },
 
+    (node) => {
+        const result = build.applyNode(
+            'mul',
+            node.args.map(arg => {
+                if (canApplyRule(ADD_EXPONENT_OF_ONE_HELPER, arg)) {
+                    return applyRule(ADD_EXPONENT_OF_ONE_HELPER, arg)
+                } else if (query.isIdentifier(arg)) {
+                    return build.applyNode('pow', [arg, build.numberNode(1)])
+                }
+                return arg
+            })
+        )
+        return result
+    }
+)
 
 // EXPONENT RULES
 
@@ -196,6 +248,97 @@ export const PRODUCT_RULE = defineRuleString('#a^#b_0 * ...', '#a^(#b_0 + ...)')
 // e.g. x^5 / x^3 -> x^(5 - 3)
 export const QUOTIENT_RULE = defineRuleString('#a^#p / #a^#q', '#a^(#p - #q)')
 
+// e.g. 3x^2 * 2x^2 -> (3 * 2)(x^2 * x^2)
+export const MULTIPLY_COEFFICIENTS = defineRule(
+    (node) => {
+        return canApplyRule(ADD_EXPONENT_OF_ONE, node) ? {node} : null
+    },
+    (node) => {
+        const terms = []
+        const coeffs = []
+        traverse(node, {
+            enter(node) {
+                if(query.isPow(node)){
+                    terms.push(node)
+                }
+            }
+        })
+        node.args.forEach(arg =>
+                          coeffs.push(getCoefficient(arg)))
+
+        const newCoeff = build.applyNode(
+            'mul',
+            coeffs
+        )
+        const newVariable = build.applyNode(
+            'mul',
+            terms
+        )
+        const result = build.applyNode(
+            'mul',
+            [newCoeff, newVariable],
+            {implicit: true}
+        )
+        return result
+    }
+)
+
+// e.g. 3x^3 * y^2 -> 3 (x^3 y^2)
+export const MULTIPLY_POLYNOMIAL_TERMS = defineRule(
+    (node) => {
+        return canApplyRule(MULTIPLY_COEFFICIENTS, node) ? {node} : null
+    },
+
+    (node) => {
+        const terms = {}
+        traverse(node, {
+            enter(node) {
+                if(query.isPow(node)){
+                    const variable = print(node.args[0])
+                    const exponent = node.args[1]
+                    if(!(variable in terms)){
+                        terms[variable] = [query.getValue(exponent)]
+                    } else {
+                        terms[variable].push(query.getValue(exponent))
+                    }
+                }
+            }
+        })
+
+        let newVariable
+
+        if(Object.keys(terms).length > 1) {
+            newVariable = build.applyNode(
+                'mul',
+                Object.keys(terms).map(key => {
+                    const exponent = terms[key].reduce((a,b) => a + b)
+                    const expression = `${key}^${exponent}`
+                    return parse(expression)
+                }), {implicit: true}
+            )
+        } else {
+            newVariable = Object.keys(terms).map(key => {
+                const exponent = terms[key].reduce((a,b) => a + b)
+                const expression = `${key}^${exponent}`
+                return parse(expression)
+            })
+            newVariable = newVariable[0]
+        }
+
+        let newCoeff = 1
+        node.args.forEach(arg => newCoeff *= query.getValue(getCoefficient(arg)))
+
+        const newCoeffNode = build.numberNode(newCoeff)
+
+        const result = build.applyNode(
+            'mul',
+            [newCoeffNode, newVariable],
+            {implicit: true}
+        )
+        return result
+    }
+)
+
 // e.g. (a * b)^x -> a^x * b^x
 export const POWER_OF_A_PRODUCT =
     defineRuleString('(#a_0 * ...)^#b', '#a_0^#b * ...')

lib/rules/collect-like-terms.js

@@ -20,7 +20,7 @@ const isPolynomial = (node) => {
 // but really we want #b to match either a number or a fraction with numbers for
 // numerator and denominator
 
-const isPolynomialTerm = (node) => {
+export const isPolynomialTerm = (node) => {
     if (query.isNumber(node)) {
         return true
     } else if (query.isIdentifier(node)) {
@@ -35,7 +35,7 @@ const isPolynomialTerm = (node) => {
     }
 }
 
-const getCoefficient = (node) => {
+export const getCoefficient = (node) => {
     if (query.isNumber(node)) {
         return node
     } else if (query.isIdentifier(node) || query.isPow(node)) {
@@ -62,7 +62,7 @@ const isVariableFactor = (node) =>
         (query.isNumber(node.args[1]) || isVariableFactor(node.args[1]))
 
 
-const getVariableFactors = (node) => {
+export const getVariableFactors = (node) => {
     if (isVariableFactor(node)) {
         return [node]
     } else if (query.isMul(node)) {
@@ -99,7 +99,7 @@ const isImplicit = (node) => {
     }
 }
 
-const getCoefficientsAndConstants = (node) => {
+export const getCoefficientsAndConstants = (node) => {
     const coefficientMap = {}
     const constants = []
 

test/rules_test.js

@@ -165,7 +165,7 @@ describe('rules', () => {
         ['x^((x + 1) / -1)', 'x^(-(x + 1) / 1)'],
     ])
 
-    suite('add numerators', rules.ADD_NUMERATORS, [
+    suite('add numerators', rules.COMBINE_NUMERATORS, [
         ['1/3 + 2/3', '(1 + 2) / 3'],
         ['1/x + 2/x + 3/x', '(1 + 2 + 3) / x'],
         ['2/3 - 1/3', '(2 - 1) / 3'],
@@ -210,6 +210,17 @@ describe('rules', () => {
         ['x^(|-(x + 1)|)', 'x^(x + 1)'],
     ])
 
+    suite('adding exponent of one helper', rules.ADD_EXPONENT_OF_ONE_HELPER, [
+        ['6x y z', '6 x^1 y^1 z^1'],
+        ['2x y^2 z', '2 x^1 y^2 z^1'],
+    ])
+
+    suite('adding exponent of one', rules.ADD_EXPONENT_OF_ONE, [
+        ['x^2 * x', 'x^2 * x^1'],
+        ['x^2 * 2 * x * x', 'x^2 * 2 * x^1 * x^1'],
+        ['2x + 3x^2 * x y z', '2 x + 3 x^2 * x^1 y^1 z^1'],
+    ])
+
     suite('collects like terms', rules.COLLECT_LIKE_TERMS, [
         ['2x + 1 - 2x', '(2 x - 2 x) + 1'],
         ['2x + 1 - x', '(2 x - x) + 1'],
@@ -294,6 +305,20 @@ describe('rules', () => {
         ['x^-a / x^-b', 'x^(-a - -b)'],
     ])
 
+    suite('multiplying coefficients', rules.MULTIPLY_COEFFICIENTS, [
+        ['x^2 * x^1', '(1 * 1) (x^2 * x^1)'],
+        ['3x^2 * x^2', '(3 * 1) (x^2 * x^2)'],
+        ['x^3 * 2y^2', '(1 * 2) (x^3 * y^2)'],
+        ['x^3 + 2x + 3x^1 * 5x^1', 'x^3 + 2 x + (3 * 5) (x^1 * x^1)'],
+    ])
+
+    suite('multiplying polynomials', rules.MULTIPLY_POLYNOMIAL_TERMS, [
+        ['x^2 * x^1', '1 x^3'],
+        ['3x^2 * x^2', '3 x^4'],
+        ['x^3 * 2y^2', '2 (x^3 y^2)'],
+        ['x^3 + 2x + 3x^1 * 5x^1', 'x^3 + 2 x + 15 x^2'],
+    ])
+
     suite('power of a product', rules.POWER_OF_A_PRODUCT, [
         ['(2*3)^x', '2^x * 3^x'],
         ['(2*3*5)^x', '2^x * 3^x * 5^x'],