Add changes

Author: eltonlaw

lib/checks/canFindDenominatorInNumerator.js

@@ -5,26 +5,20 @@ const Node = require('../node');
 // e.g. (2x+1)/(2x+3) -> True because of the following simplification
 // (2x+1)/(2x+3) -> (2x + 3)/(2x + 3) - 2/(2x + 3) -> 1 - 2/(2x + 3)
 // e.g. (2x+1)/(2x^2 + 3) -> False
-// =========================================================================
+// ==============================================================================
 // CHECKS
 // - Check for division in parent node
-// - Check that the number of arguments in parent node is 2
-// - Check that the number of numerator args is equal to 2 or 1. In the case
-// - of 1, we need that node to have a symbol (so it can't be a constant)
-// - Check that denominator has two args
-// - Check that the denominator op is '+' or '-'
-// - If the numerator has 2 args, check that the second arg is a constant node
-// - Check if the denominator's second arg is a constant node
-// - Check to see that the denominator and numerator both don't have exponents
+// - Numerator has to be addition/subtraction of a polynomial term to the power
+//   of 1 and a constant term, in that order OR a polynomial term to the
+//   power of 1
+// - Denominator has to be addition/subtraction of a polynomial term to the power
+//   of 1 and a constant term, in that order.
 // - Check to see that the denominator and numerator have the same symbol
 
 function canFindDenominatorInNumerator(node) {
   if (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)) {
@@ -35,35 +29,36 @@ function canFindDenominatorInNumerator(node) {
   }
 
   let numeratorArgsLength;
-  // If numerator is '*' op, it signifies a single 'ax', should be assigned a
-  // length of 2
-  if ('args' in numerator &&
-      (numerator.op === '+' || numerator.op === '-')) {
+  // If numerator has args, but it's just a polynomial term, length is 1
+  // Ex. 3x/2x+3 => numeratorArgsLength=1
+  if (Node.PolynomialTerm.isPolynomialTerm(numerator)) {
+    numeratorArgsLength = 1;
+  }
+  // If numerator has args and args are two seperate values length is 2
+  // Ex. 3x+4/2x+3 => numeratorArgsLength=2
+  else if (numerator.op === '+' || numerator.op === '-') {
     numeratorArgsLength = numerator.args.length;
   }
+  // If numerator doesn't have args and isn't a polynomial term, there's
+  // nothing the added functionality can do
+  // Ex. 3/(2x + 3) => False
   else {
-    numeratorArgsLength = 1;
+    return false;
   }
   let denominatorArgsLength;
-  if ('args' in denominator) {
+  if (denominator.op === '+' || denominator.op === '-') {
     denominatorArgsLength = denominator.args.length;
   }
+  // If denominator doesn't have args, it's length is 1. This case is already
+  // resolved by splitting the denominator into all the numerators
+  // Ex. (x + 3)/2x => x/2x + 3/2x
   else {
-    denominatorArgsLength = 1;
-  }
-  // If numerator args isn't length 2 or length 1 with a polynomial return false
-  if (numeratorArgsLength !== 2 &&
-     (!(numeratorArgsLength === 1 && !Node.Type.isConstant(numerator)))) {
     return false;
   }
   // Function doesn't support denominators with args > 2
-  // If denominatorArgsLength = 1 the normal functionality already covers it
   if (denominatorArgsLength !== 2) {
     return false;
   }
-  if (!(denominator.op === '+' || denominator.op === '-')) {
-    return false;
-  }
   // Check if numerator's second argument is a constant if numerator has two arguments
   if (numeratorArgsLength === 2) {
     if (!Node.Type.isConstant(numerator.args[1])) {