Fractions

lib/__test__/rule-list.test.js

@@ -172,21 +172,49 @@ describe('rules', () => {
         ['x^((x + 1) / -1)', 'x^(-(x + 1) / 1)'],
     ])
 
-    suite('add numerators', rules.COMBINE_NUMERATORS, [
+    suite('rewrite fractional polynomial', rules.REWRITE_FRACTIONAL_POLYNOMIAL, [
+        ['2x/3', '2 / 3 x'],
+        ['2x^2/3', '2 / 3 x^2'],
+        ['2(x+1)^2/3', '2 / 3 (x + 1)^2'],
+        ['2xyz/3', '2 / 3 xyz'],
+    ])
+
+    suite('combine 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'],
         ['(1/3 + 2/3) / x', '(1 + 2) / 3 / x'],
     ])
 
-    suite('common denominators', rules.COMMON_DENOMINATOR, [
+    suite('convert to fraction', rules.CONVERT_TO_FRACTION, [
+        ['2/3 + x', '2 / 3 + x / 1'],
+        ['2/3 - x', '2 / 3 - x / 1'],
+        ['2/3 - x - 2', '2 / 3 - x / 1 - 2 / 1'],
+        ['2/(3 + x) + 2 + (x + 1)^2', '2 / (3 + x) + 2 / 1 + (x + 1)^2 / 1'],
+        ['2.2 + 3/4', '11 / 5 + 3 / 4'],
+        ['1.33 + 2.12 + 2/3', '133 / 100 + 53 / 25 + 2 / 3'],
+        ['1.44 - 2 - 3/4', '36 / 25 - 2 / 1 - 3 / 4'],
+        ['-2 + 3.33 + 2/3', '-2 / 1 + 333 / 100 + 2 / 3']
+    ])
+
+    suite('common denominators', rules.COMMON_DENOMINATOR, [ 
         ['2/6 + 1/4', '(2 * 2) / (6 * 2) + (1 * 3) / (4 * 3)'],
+        ['2/(3 + x) + 3/(2 + x)', '(2 * (2 + x)) / ((3 + x) * (2 + x)) + (3 * (3 + x)) / ((3 + x) * (2 + x))'],
+        ['2/5 + 1/(3x + 7)', '(2 * (3 x + 7)) / (5 * (3 x + 7)) + (1 * 5) / (5 * (3 x + 7))'], 
         ['2/6 - 1/4', '(2 * 2) / (6 * 2) - (1 * 3) / (4 * 3)'],
         ['2/6 + 1/4 - 2/5', '(2 * 10) / (6 * 10) + (1 * 15) / (4 * 15) - (2 * 12) / (5 * 12)'],
         ['2/6 + 1/4 - 3/4', '(2 * 2) / (6 * 2) + (1 * 3) / (4 * 3) - (3 * 3) / (4 * 3)'],
-        // TODO: return the original expression if the denominators are already
-        // the same?
-        ['2/4 - 1/4', '(2 * 1) / (4 * 1) - (1 * 1) / (4 * 1)'],
+        ['(3 + x)/2 + 2/(3 + x) + 2/3', '((3 + x) * (3 + x) * 3) / (2 * (3 + x) * 3) + (2 * 2 * 3) / (2 * (3 + x) * 3) + (2 * 2 * (3 + x)) / (2 * (3 + x) * 3)'],
+        // Some terms have same denom 
+        ['2/3 + 2/3 + 1/4 + 1/4', '(2 * 4) / (3 * 4) + (2 * 4) / (3 * 4) + (1 * 3) / (4 * 3) + (1 * 3) / (4 * 3)'],
+        // Number surrounded by fraction
+        ['3 + 2/3', '(3 * 3) / 3 + 2 / 3'],
+        ['x + 2 + 3/4', '(x * 4) / 4 + (2 * 4) / 4 + 3 / 4'],
+        ['(x + 1)^2 + 2/3', '((x + 1)^2 * 3) / 3 + 2 / 3'],
+        ['2(x + 1)^2 + 2/3', '(2 (x + 1)^2 * 3) / 3 + 2 / 3'],
+        ['2/3 - x - 2', '2 / 3 - (x * 3) / 3 - (2 * 3) / 3'],
+        ['2/3 - x/3 - 2/4', '(2 * 4) / (3 * 4) - (x * 4) / (3 * 4) - (2 * 3) / (4 * 3)'],
+        ['-2 + 3 - 2/4', '-(2 * 4) / 4 + (3 * 4) / 4 - 2 / 4'],
     ])
 
     suite('multiply fractions', rules.MULTIPLY_FRACTIONS, [

lib/rule-list.js

@@ -82,6 +82,7 @@ export const EVALUATE_POWER = defineRuleString(
 // e.g. -(-3) -> 3
 export const NEGATION = defineRuleString('--#a', '#a')
 
+// e.g. x * 5 -> 5 x
 export const REARRANGE_COEFF = defineRuleString('#b * #a', '#a #b', {a: query.isNumber, b: isPolynomialTerm})
 
 // ARITHMETIC
@@ -133,7 +134,6 @@ export const RESOLVE_DOUBLE_MINUS = defineRuleString('#a - -#b', '#a + #b')
 // e.g -3 * -2 -> 3 * 2
 export const MULTIPLY_NEGATIVES = defineRuleString('-#a * -#b', '#a * #b')
 
-
 // FRACTIONS
 
 // e.g. (x + 1) / 2 -> x / 2 + 1 / 2
@@ -155,17 +155,181 @@ export const SIMPLIFY_FRACTION = defineRuleString(
 // e.g. 2/-3 -> -2/3
 export const SIMPLIFY_SIGNS = defineRuleString('#a / -#b', '-#a / #b')
 
+// e.g. 2x/3 -> 2/3 x
+export const REWRITE_FRACTIONAL_POLYNOMIAL = defineRuleString(
+    '#a #b / #c', '#a / #c #b', {a: query.isNumber, b: isPolynomialTerm, c: query.isNumber}
+)
 
 // ADDING FRACTIONS
 
+// e.g. 2/5 + 2/5 -> (2 + 2)/5
 export const COMBINE_NUMERATORS =
     defineRuleString('#a_0 / #b + ...', '(#a_0 + ...) / #b')
 
-export const COMMON_DENOMINATOR =
-    defineRuleString(
-        '#a_0 / #b_0 + ...',
-        '(#a_0 * #eval(lcm(#b_0, ...) / #b_0)) / (#b_0 * #eval(lcm(#b_0, ...) / #b_0)) + ...'
-    )
+
+export const getNegatives = (arr) => arr.map(arg => query.isNeg(arg))
+
+export const isFraction = (node) => query.isNeg(node)
+    ? query.isDiv(node.args[0])
+    : query.isDiv(node)
+
+export const getNumerator = (node) => query.isNeg(node)
+    ? node.args[0].args[0]
+    : node.args[0]
+
+export const getDenominator = (node) => query.isNeg(node)
+    ? node.args[0].args[1]
+    : node.args[1]
+
+export const isDecimal = (node) => query.isNumber(node) && query.getValue(node) % 1 != 0
+
+export const decimal_to_fraction = (node) => {
+    // split up the decimal
+    const [int, dec] = node.value.toString().split('.')
+
+    // e.g. .2 -> 2/10
+    const fraction = build.div(build.number(parseInt(dec)), build.number(parseInt('1' + '0'.repeat(dec.length))))
+
+    // simplified the fraction if possible 
+    const simplified = canApplyRule(SIMPLIFY_FRACTION, fraction)
+          ? applyRule(SIMPLIFY_FRACTION, fraction)
+          : fraction
+
+    const newNumerator = parseInt(int) * query.getValue(simplified.args[1]) + query.getValue(simplified.args[0])
+    return build.div(build.number(newNumerator), simplified.args[1])
+}
+
+// e.g. 2 + 3/2 -> 2/1 + 3/2
+// e.g. 1.2 + 3/2 -> 6/5 + 3/2
+export const CONVERT_TO_FRACTION = defineRule(
+    (node) => {
+        if (query.isAdd(node)) {
+            const terms = node.args
+            // only some of the terms are fractions
+            const hasFraction = terms.some(term => isFraction(term)) && !terms.every(term => isFraction(term))
+
+            return hasFraction ? {node} : null
+        }
+    },
+
+    (node) => {
+        let terms = node.args
+
+        const negatives = getNegatives(terms)
+
+        // transform constant terms
+        terms = terms.map(term => isDecimal(term) && query.isNeg(term)
+                          ? decimal_to_fraction(term.args[0])
+                          : isDecimal(term)
+                          ? decimal_to_fraction(term)
+                          : isPolynomialTerm(term) && query.isNeg(term)
+                          ? build.div(term.args[0], build.number(1))
+                          : isPolynomialTerm(term)
+                          ? build.div(term, build.number(1))
+                          : query.isNeg(term)
+                          ? term.args[0]
+                          : term)
+
+        const result = build.add(
+            ...terms.map((term, i) => negatives[i]
+                         ? build.neg(term, {wasMinus: true})
+                         : term))
+        return result
+    }
+)
+
+// Finds common denominator in any scenario
+
+// e.g. 2/6 + 1/4 -> (2 * 2) / (6 * 2) + (1 * 3) / (4 * 3)
+// e.g. 2/(3 + x) + 2/3 -> (2 * 3)/ (3 * (3 + x)) + 2 * (3 + x) / (3 * (3 + x))
+// e.g. 3 + 2/3 -> (3 * 3) / 3 + 2 / 3
+export const COMMON_DENOMINATOR = defineRule(
+    (node) => {
+        if (query.isAdd(node)) {
+            const terms = node.args
+
+            // checks if at least one of the terms is a fraction
+            const hasFraction = terms.some(term => isFraction(term))
+
+            let sameDenom
+            // rule cannot apply if all of the terms are fractions
+            // and they all have the same denominator
+            if (terms.every(term => isFraction(term))) {
+                const denom = getDenominator(terms[0])
+
+                sameDenom = terms.every(term =>
+                                        print(getDenominator(term)) == print(denom))
+            }
+
+            return hasFraction && !sameDenom ? {node} : null
+        }
+    },
+
+    (node) => {
+        node = canApplyRule(CONVERT_TO_FRACTION, node)
+            ? applyRule(CONVERT_TO_FRACTION, node)
+            : node
+
+        let terms = node.args
+        // an array storing the index where fraction is negative
+        const negatives = getNegatives(terms)
+
+        // get numerators and denominators of all fractions
+        let nums = terms.map(term => getNumerator(term))
+        let denoms = terms.map(term => getDenominator(term))
+        let newDenoms
+        let newNumerators
+
+        /*
+          If all denoms are numbers, the new denom is
+          the [denom * (LCM / denom)] and the new numerators
+          is [num * (LCM / denom)]
+
+          Else the new denom is the product of all the terms
+          and the new numerator is [num * all other denoms]
+        */
+
+        if(denoms.every(denom => query.isNumber(denom))) {
+            denoms = denoms.map(denom => query.getValue(denom))
+            const LCM = lcm(...denoms)
+
+            // remove multiplication by 1
+            newDenoms = denoms.map(
+                denom => denom == 1 
+                    ? build.number(LCM / denom)
+                    : LCM / denom == 1
+                    ? build.number(denom)
+                    : build.mul(build.number(denom),
+                                build.number(LCM / denom)))
+            newNumerators = nums.map(
+                (num, i) => LCM / denoms[i] == 1
+                    ? num
+                    : build.mul(num,
+                                build.number(LCM / denoms[i])))
+        } else {
+            newDenoms = build.mul(...denoms)
+            newNumerators = nums.map(
+                (num, i) => build.mul(num, ...denoms.filter(e => e != denoms[i])))
+        }
+
+        /*
+          The newDenoms variable is an array when all the denoms
+          are numbers because all the newDenoms are different.
+        */
+
+        const result = Array.isArray(newDenoms)
+              ? build.add(...newDenoms.map(
+                  (den, i) => negatives[i]
+                      ? build.neg(build.div(newNumerators[i], den), {wasMinus: true})
+                      : build.div(newNumerators[i], den)))
+              : build.add(...newNumerators.map(
+                  (num, i) => negatives[i]
+                      ? build.neg(build.div(num, newDenoms), {wasMinus: true})
+                      : build.div(num, newDenoms)))
+
+        return result
+    }
+)
 
 // Have a 'negatives' array which marks things as being negative or not for
 // items in a variable length node.  When we're populating that variable length

lib/rules/collect-like-terms.js

@@ -28,7 +28,7 @@ export const isPolynomialTerm = (node) => {
         return true
     } else if (query.isPow(node)) {
         const [base, exponent] = node.args
-        return query.isIdentifier(base) && isPolynomialTerm(exponent)
+        return (query.isIdentifier(base) || isPolynomial(base)) && isPolynomialTerm(exponent)
     } else if (query.isNeg(node)) {
         return isPolynomialTerm(node.args[0])
     } else if (query.isMul(node)) {