Package lipstone.joshua.parser.util

Examples of lipstone.joshua.parser.util.ConsCell

1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
   * @return true if the equation contains at least one of the variables, false otherwise
   * @see #containsVariables(ConsCell, ArrayList) containsVariable(ConsCell input, ArrayList<String> variables)
   * @see #containsVariables(ConsCell) containsVariable(ConsCell input)
   */
  public boolean containsVariables(ConsCell input, ArrayList<String> variables, ArrayList<String> otherOps) {
    ConsCell current = input;
    do {
      if (current.getCarType() == ConsType.IDENTIFIER && !allNames.contains(current.getCar()) && !otherOps.contains(current.getCar()) && variables.contains(current.getCar()))
        return true;
      if (current.getCarType() == ConsType.CONS_CELL && containsVariables(((ConsCell) current.getCar()), variables, otherOps))
        return true;
    } while (!((current = current.getNextConsCell()).isNull())); //This steps current forward while checking for nulls
    return false;
  }
View Full Code Here
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
   * @param input
   *            the section of the equation to be checked and fixed, if applicable
   * @return the input with the above cases removed
   */
  public ConsCell removeDoubles(ConsCell input) {
    ConsCell current = input, next = current.getNextConsCell();
    if (next.isNull())
      return input;
    boolean step = true;
    do {
      step = true;
      if (current.getCarType() == ConsType.CONS_CELL) {
        current.replaceCar(removeDoubles((ConsCell) current.getCar()));
        continue;
      }
      if (current.getCarType() != ConsType.OPERATOR || next.getCarType() != ConsType.OPERATOR)
        continue;
      char currentCar = (Character) current.getCar(), nextCar = (Character) next.getCar();
      if ((currentCar == '*' && nextCar == '/') || (currentCar == '/' && nextCar == '*')) {
        next.remove();
        current.replaceCar(new ConsCell('/', ConsType.OPERATOR));
        step = false;
      }
      if ((currentCar == '-' && nextCar == '-') || (currentCar == '+' && nextCar == '+')) {
        next.remove();
        current.replaceCar(new ConsCell('+', ConsType.OPERATOR));
        step = false;
      }
      if ((currentCar == '-' && nextCar == '+') || (currentCar == '+' && nextCar == '-')) {
        next.remove();
        current.replaceCar(new ConsCell('-', ConsType.OPERATOR));
        step = false;
      }
      if (nextCar == '^')
        current.insert(new ConsCell(BigDec.ZERO, ConsType.NUMBER));
      next = current.getNextConsCell();
    } while (!step || (step && !((current = current.getNextConsCell()).isNull() || (next = current.getNextConsCell()).isNull()))); //This steps current forward while checking for nulls
   
    return input;
  }
View Full Code Here
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
  public ArrayList<ParserPlugin> getPlugins() {
    return plugins;
  }
 
  public ConsCell replaceKeywords(ConsCell input) throws SyntaxException, UnbalancedParenthesesException, ParserException {
    ConsCell current = input;
    do {
      if (current.getCarType() == ConsType.IDENTIFIER) {
        if (keywords.containsKey(current.getCar()))
          current.replaceCar(Tokenizer.tokenizeString(((KeywordPlugin) this.keywords.get(current.getCar()).getPlugin()).getKeywordData((String) current.getCar())));
      }
      if (current.getCarType() == ConsType.CONS_CELL)
        current.replaceCar(replaceKeywords((ConsCell) current.getCar()));
    } while (!((current = current.getNextConsCell()).isNull())); //This steps current forward while checking for nulls
    return input;
  }
View Full Code Here
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
  }
 
  public ConsCell polynomialDivision(ConsCell dividend, ConsCell divisor, ConsCell var, boolean flagRemainder) throws ParserException {
    BigDec[] dividendCoefficients = getSyntheticCoefficients(dividend, var);
    if (dividendCoefficients == null)
      return new ConsCell("{false}", ConsType.OBJECT);
    BigDec[] divisorCoefficients = getSyntheticCoefficients(divisor, var);
    if (divisorCoefficients == null)
      return new ConsCell("{false}", ConsType.OBJECT);
   
    int resultOrder = dividendCoefficients.length - divisorCoefficients.length;
    ConsCell result = new ConsCell();
    for (int i = 0; i <= resultOrder; i++) {
      BigDec resultCoefficient = dividendCoefficients[i].divide(divisorCoefficients[0]);
      dividendCoefficients[i] = BigDec.ZERO;
      for (int j = 1; j < divisorCoefficients.length; j++)
        dividendCoefficients[i + j] = dividendCoefficients[i + j].subtract(divisorCoefficients[j].multiply(resultCoefficient));
      result = result.append(new ConsCell('+', ConsType.OPERATOR, new ConsCell(resultCoefficient, ConsType.NUMBER, new ConsCell('*', ConsType.OPERATOR, new ConsCell(var, ConsType.CONS_CELL,
          new ConsCell('^', ConsType.OPERATOR, new ConsCell(new BigDec(resultOrder - i), ConsType.NUMBER)))))));
    }
    ConsCell remainder = new ConsCell();
    for (int i = 0; i < dividendCoefficients.length; i++)
      if (dividendCoefficients[i].neq(BigDec.ZERO))
        remainder = remainder.append(new ConsCell('+', ConsType.OPERATOR, new ConsCell(dividendCoefficients[i], ConsType.NUMBER, new ConsCell('*', ConsType.OPERATOR,
            new ConsCell(var, ConsType.CONS_CELL, new ConsCell('^', ConsType.OPERATOR, new ConsCell(new BigDec(dividendCoefficients.length - 1 - i), ConsType.NUMBER)))))));
    remainder = remainder.getFirstConsCell();
    if (!remainder.isNull()) {
      remainder = remainder.remove();
      remainder = new ConsCell(remainder, ConsType.CONS_CELL, new ConsCell('/', ConsType.OPERATOR, new ConsCell(divisor.clone(), ConsType.CONS_CELL), ConsType.CONS_CELL), ConsType.CONS_CELL);
      result = result.append(new ConsCell('+', ConsType.OPERATOR, remainder, ConsType.CONS_CELL));
    }
    result = result.getFirstConsCell();
    if (!result.isNull())
      result = simplifyTerms(result.remove());
    if (flagRemainder)
      result.getLastConsCell().append(new ConsCell("{" + !remainder.isNull() + "}", ConsType.OBJECT));
    return result;
  }
View Full Code Here
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
    ArrayList<ConsCell> terms = foldSigns(getTerms(simplifyTerms(equation)));
    BigDec equationOrder = BigDec.ZERO;
    for (ConsCell term : terms)
      termOrders.add(orderOfTerm(term, vars));
    for (PairedList<ConsCell, ConsCell> order : termOrders) {
      ConsCell temp = order.containsKey(var) ? parser.run(order.get(var)) : new ConsCell(BigDec.ZERO, ConsType.NUMBER);
      if (temp.length() != 1 || temp.getCarType() != ConsType.NUMBER || ((BigDec) temp.getCar()).lt(BigDec.ZERO) || !((BigDec) temp.getCar()).isInt())
        return null;
      if (((BigDec) temp.getCar()).gt(equationOrder))
        equationOrder = (BigDec) temp.getCar();
    }
    int highestOrder = equationOrder.intValue();
    BigDec[] equationCoefficients = new BigDec[highestOrder + 1];
    for (int i = 0; i < equationCoefficients.length; i++)
      equationCoefficients[i] = BigDec.ZERO;
    for (int i = 0; i < terms.size(); i++) {
      ConsCell temp = termOrders.get(i).containsKey(var) ? parser.run(termOrders.get(i).get(var)) : new ConsCell(BigDec.ZERO, ConsType.NUMBER);
      equationCoefficients[highestOrder - ((BigDec) temp.getCar()).intValue()] = equationCoefficients[highestOrder - ((BigDec) temp.getCar()).intValue()].add(getCoefficient(terms.get(i)));
    }
    return equationCoefficients;
  }
View Full Code Here
453
454
455
456
457
458
459
460
461
462
463
464
465
      while (num.mod(prime).eq(BigDec.ZERO)) {
        factors.add(primes[i]);
        num = num.divide(prime);
      }
    }
    ConsCell output = new ConsCell();
    for (long integer : factors)
      output = output.append(new ConsCell(",", ConsType.SEPARATOR)).append(new ConsCell(new BigDec(integer), ConsType.NUMBER));
    output = output.getFirstConsCell();
    if (output.getCarType() == ConsType.SEPARATOR)
      output = output.remove();
    return output;
  }
View Full Code Here
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
  }
 
  private ArrayList<BigDec> substitutionSolve(ConsCell equation) throws ParserException {
    ArrayList<String> initialVars = new ArrayList<String>(parser.getVars());
    ArrayList<BigDec> tempSolutions = new ArrayList<BigDec>(), solutions = new ArrayList<BigDec>();
    ConsCell parts[] = seekSubstitutions(equation.clone());
    if (parser.getVariables(parts[0]).size() > 1)
      return solutions;
    tempSolutions = solve(parts[0], false, false);
    if (parts[1].isNull()) {
      for (int i = 0; i < tempSolutions.size(); i++)
        if (!isAnswer(equation, tempSolutions.get(i), BigDec.ZERO, accuracy)) {
          tempSolutions.remove(i);
          i--;
        }
      return tempSolutions;
    }
    else {
      parser.setVars(initialVars);
      for (BigDec d : tempSolutions) {
        try {
          ConsCell deSubEqn = reverseSubstitution(parts[1], d);
          initialInput.push(deSubEqn);
          for (BigDec solutin : solve(deSubEqn, true, false))
            solutions.add(solutin);
        }
        finally {
View Full Code Here
579
580
581
582
583
584
585
586
587
    return checkSolutions(solutions, equation, accuracy);
  }
 
  private ConsCell reverseSubstitution(ConsCell substitution, BigDec z) throws ParserException {
    int subID = subID(substitution);
    ConsCell deSubEqn = parser.run(reverseSubstitutions[subID].replaceAll("z", z.toString()));
    return removeExcessParentheses(subID == substitutions.length - 1 ? substitution.clone() : substitution.getNextConsCell().clone()).getLastConsCell().append(
        parser.removeDoubles(new ConsCell('+', ConsType.OPERATOR, invertSign(deSubEqn)))).getFirstConsCell();
  }
View Full Code Here
595
596
597
598
599
600
601
        return i;
    return -1;
  }
 
  private ConsCell[] seekSubstitutions(ConsCell equation) throws ParserException {
    return seekSubstitutions(equation, new ConsCell());
  }
View Full Code Here
599
600
601
602
603
604
605
  private ConsCell[] seekSubstitutions(ConsCell equation) throws ParserException {
    return seekSubstitutions(equation, new ConsCell());
  }
 
  public ConsCell[] seekSubstitutions(ConsCell equation, ConsCell substitution) throws ParserException {
    return seekSubstitutions(equation, substitution, new ConsCell("y", ConsType.IDENTIFIER));
  }
View Full Code Here
TOP

Related Classes of lipstone.joshua.parser.util.ConsCell

  • anglecommands.AngleCommands
  • calculus.Calculus
  • calculus.NIThread
  • core.BasicPlugin
  • lipstone.joshua.parser.backend.StepSolveThread
  • lipstone.joshua.parser.CAS
  • lipstone.joshua.parser.Parser
  • lipstone.joshua.parser.plugin.ParserPlugin
  • lipstone.joshua.parser.plugin.settings.ParserSettingsCheckBox
  • lipstone.joshua.parser.plugin.settings.ParserSettingsComboBox
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.