#76 - Better break-up fraction.

lib/checks/canFindDenominatorInNumerator.js

@@ -0,0 +1,35 @@
+const Node = require('../node');
+
+// Returns true if by adding a term you can simplify part of the function into an integer
+// e.g. (2x+1)/(2x+3) -> True
+// e.g. (2x+1)/(2x^2 + 3) -> False
+function canFindDenominatorInNumerator(node) {
+  if (!Node.Type.isOperator(node) || node.op !== '/' ) {
+    return false;
+  }
+  if (node.args.length !== 2) {
+    return false;
+  }
+
+  let numerator = node.args[0];
+  let denominator = node.args[1];
+  if (Node.Type.isParenthesis(numerator)) {
+    numerator = numerator.content;
+  }
+  if (Node.Type.isParenthesis(denominator)) {
+    denominator = denominator.content;
+  }
+
+  if (numerator.op !== '+') {
+    return false;
+  }
+  if (!('args' in denominator)) {
+    return false;
+  }
+  const numeratorFirstTerm = new Node.PolynomialTerm(numerator.args[0]);
+  const denominatorFirstTerm = new Node.PolynomialTerm(denominator.args[0]);
+
+  return numeratorFirstTerm.getSymbolName() === denominatorFirstTerm.getSymbolName();
+}
+
+module.exports = canFindDenominatorInNumerator;

lib/checks/canSimplifyPolynomialTerms.js

@@ -1,11 +1,13 @@
 const canAddLikeTermPolynomialNodes = require('./canAddLikeTermPolynomialNodes');
+const canFindDenominatorInNumerator = require('./canFindDenominatorInNumerator');
 const canMultiplyLikeTermPolynomialNodes = require('./canMultiplyLikeTermPolynomialNodes');
 const canRearrangeCoefficient = require('./canRearrangeCoefficient');
 
 // Returns true if the node is an operation node with parameters that are
 // polynomial terms that can be combined in some way.
 function canSimplifyPolynomialTerms(node) {
   return (canAddLikeTermPolynomialNodes(node) ||
+          canFindDenominatorInNumerator(node) ||
           canMultiplyLikeTermPolynomialNodes(node) ||
           canRearrangeCoefficient(node));
 }

lib/checks/index.js

@@ -1,4 +1,5 @@
 const canAddLikeTermPolynomialNodes = require('./canAddLikeTermPolynomialNodes');
+const canFindDenominatorInNumerator = require('./canFindDenominatorInNumerator');
 const canMultiplyLikeTermPolynomialNodes = require('./canMultiplyLikeTermPolynomialNodes');
 const canRearrangeCoefficient = require('./canRearrangeCoefficient');
 const canSimplifyPolynomialTerms = require('./canSimplifyPolynomialTerms');
@@ -8,6 +9,7 @@ const resolvesToConstant = require('./resolvesToConstant');
 
 module.exports = {
   canAddLikeTermPolynomialNodes,
+  canFindDenominatorInNumerator,
   canMultiplyLikeTermPolynomialNodes,
   canRearrangeCoefficient,
   canSimplifyPolynomialTerms,

lib/simplifyExpression/breakUpNumeratorSearch/index.js

@@ -1,3 +1,4 @@
+const canFindDenominatorInNumerator = require('../../checks/canFindDenominatorInNumerator');
 const ChangeTypes = require('../../ChangeTypes');
 const Node = require('../../node');
 const TreeSearch = require('../../TreeSearch');
@@ -27,8 +28,33 @@ function breakUpNumerator(node) {
   // At this point, we know that node is a fraction and its numerator is a sum
   // of terms that can't be collected or combined, so we should break it up.
   const fractionList = [];
-  const denominator = node.args[1];
-  numerator.args.forEach(arg => {
+  let denominator = node.args[1];
+
+  // Check if we can add a constant to make the fraction nicer
+  // fraction e.g. (2+x)/(5+x) -> (5+x)/(5+x) + 3/(5+x)
+  if (canFindDenominatorInNumerator(node)) {
+    let denominatorParenRemoved = false;
+    if (Node.Type.isParenthesis(denominator)) {
+      denominatorParenRemoved = true;
+      denominator = denominator.content;
+    }
+    const newNumerator = [];
+
+    // The constant value difference between the numerator and the denominator
+    const numeratorConstant = parseInt(numerator.args[1].value);
+    const denominatorConstant = parseInt(denominator.args[1].value);
+    const addedConstant = numeratorConstant - denominatorConstant;
+
+    newNumerator.push(Node.Creator.constant(addedConstant));
+    newNumerator.push(denominator);
+
+    numerator = newNumerator;
+
+    if (denominatorParenRemoved) {
+      denominator = Node.Creator.parenthesis(denominator);
+    }
+  }
+  numerator.forEach(arg => {
     const newFraction = Node.Creator.operator('/', [arg, denominator]);
     newFraction.changeGroup = 1;
     fractionList.push(newFraction);
@@ -41,5 +67,4 @@ function breakUpNumerator(node) {
   return Node.Status.nodeChanged(
     ChangeTypes.BREAK_UP_FRACTION, node, newNode, false);
 }
-
 module.exports = search;

test/checks/checks.test.js

@@ -29,3 +29,10 @@ describe('canSimplifyPolynomialTerms addition', function() {
   ];
   tests.forEach(t => testCanCombine(t[0], t[1]));
 });
+
+describe('canSimplifyPolynomialTerms denominator in numerator', function() {
+  const tests = [
+    ['(2x + 3)/(2x + 2)', true],
+  ];
+  tests.forEach(t => testCanCombine(t[0], t[1]));
+});

test/simplifyExpression/breakUpNumeratorSearch/breakUpNumeratorSearch.test.js

@@ -11,6 +11,7 @@ describe('breakUpNumerator', function() {
     ['(x+3+y)/3', '(x / 3 + 3/3 + y / 3)'],
     ['(2+x)/4', '(2/4 + x / 4)'],
     ['2(x+3)/3', '2 * (x / 3 + 3/3)'],
+    ['(2x + 3)/(2x + 2)', '(1 / (2x + 2) + (2x + 2) / (2x + 2))'],
   ];
   tests.forEach(t => testBreakUpNumeratorSearch(t[0], t[1]));
 });