محلل تعبير جافا الرياضي الذي يمكن أن يأخذ الأعداد المركبة كمتغير؟

Question

أنا أكتب برنامج في يعالج الذي يحول الأعداد المركبة.ومع ذلك، أريد أن يكون لدي طريقة لأخذ سلسلة إدخال وحساب التحويل باستخدام متغير معقد.على سبيل المثال:

1/(z+1)
(z^2)/(z/2)

حيث z هو عدد مركب.الآن، لقد ألقيت نظرة على JEP وبعضها أمثلة, ، لكن لا يمكنني معرفة ما إذا كان ذلك سيسمح لك بإدخال z كمتغير (وهو ليس مجانيًا على أية حال).هل يوجد محلل تعبير لـ Java (يعمل في المعالجة، ويستخدم إصدارًا قديمًا من Java ولا يحتوي على مواد عامة) يمكنني استخدامه للقيام بذلك؟

إذا لم يكن الأمر كذلك، فهل يمكن لأي شخص أن يوجهني إلى أساسيات كيفية إنشاء واحد؟

Answer 1

وكما ذكر من قبل فيلو، يمكنك استخدام الأدوية. جرب هذا رسم المعالجة:

import java.util.*;
java.util.List<String> list = Arrays.asList("a", "b", "c");
textFont(loadFont("UMingCN-30.vlw"));
for(int i = 0; i < list.size(); i++) {
  text(list.get(i), 5, int(i*30)+30);
}

وهناك نسخة غير التجاري للJEP المتاحة (GPL). تحميل البرنامج <لأ href = "http://sourceforge.net/projects/jep/files/JEP/2.4.1/jep-2.4.1-ext-1.1.1-gpl.zip/download" يختلط = "نوفولو noreferrer "> هنا وإضافته إلى CLASSPATH معالجة الخاص بك (استيراده). بعد القيام بنجاح بذلك، يمكنك استخدام JEP مثل هذا:

void setup() {
  org.nfunk.jep.JEP parser = new org.nfunk.jep.JEP();
  parser.addComplex();
  try {
    parser.parseExpression("(1+2*i) + (3+8*i)");
    println(parser.getComplexValue());
  } catch(Exception e) {
    e.printStackTrace();
  }
}

والتي تنتج (المتوقع) إخراج: (4.0، 10.0)

Answer 2

وإلقاء نظرة على هذا: http://bracer.sourceforge.net انها تنفيذ بلدي قاطرات ياردة خوارزمية وهذا المحلل تدعم الأرقام المعقدة.

Answer 3

إذا لسبب ما كنت بحاجة الى مزيد من المرونة من "المعلبة" معقدة موزعي التعبير الرياضيات اقترح حتى الآن (= السيطرة الكاملة على المشغلين، الأسبقية، وبناء شجرة)، قد ترغب في النظر في بلدي محلل شكلي:

https://github.com/stefanhaustein/expressionparser

مثال كود التقييم المباشر لقضيتك:

static HashMap<String, Complex> variables = new HashMap<>();

/**
 * Processes the calls from the parser directly to a Complex value.
 */
static class ComplexProcessor extends ExpressionParser.Processor<Complex> {
  @Override
  public Complex infixOperator(ExpressionParser.Tokenizer tokenizer, String name, Complex left, Complex right) {
    switch (name.charAt(0)) {
      case '+': return left.plus(right);
      case '-': return left.minus(right);
      case '*': return left.times(right);
      case '/': return left.divides(right);
      case '^':
        if (right.im() != 0 || right.re() == (int) right.re()) {
          return left.pow((int) right.re());
        }
        throw new RuntimeException("Only integer exponents supported by Complex.pow().");
      default:
        throw new IllegalArgumentException();
    }
  }

  @Override
  public Complex prefixOperator(ExpressionParser.Tokenizer tokenizer, String name, Complex argument) {
    return name.equals("-") ? new Complex(0,0).minus(argument) : argument;
  }

  @Override
  public Complex numberLiteral(ExpressionParser.Tokenizer tokenizer, String value) {
    return new Complex(Double.parseDouble(value), 0);
  }

  @Override
  public Complex identifier(ExpressionParser.Tokenizer tokenizer, String name) {
    Complex value = variables.get(name);
    if (value == null) {
      throw new IllegalArgumentException("Undeclared variable: " + name);
    }
    return value;
  }

  @Override
  public Complex group(ExpressionParser.Tokenizer tokenizer, String paren, List<Complex> elements) {
    return elements.get(0);
  }

  /**
   * Creates a parser for this processor with matching operations and precedences set up.
   */
  static ExpressionParser<Complex> createParser() {
    ExpressionParser<Complex> parser = new ExpressionParser<Complex>(new ComplexProcessor());
    parser.addCallBrackets("(", ",", ")");
    parser.addGroupBrackets("(", null, ")");
    parser.addOperators(ExpressionParser.OperatorType.INFIX_RTL, 4, "^");
    parser.addOperators(ExpressionParser.OperatorType.PREFIX, 3, "+", "-");
    // 2 Reserved for implicit multiplication
    parser.addOperators(ExpressionParser.OperatorType.INFIX, 1, "*", "/");
    parser.addOperators(ExpressionParser.OperatorType.INFIX, 0, "+", "-");
    return parser;
  }
}

مثال الاحتجاج:

  variables.put("i", new Complex(0, 1));
  variables.put("z", new Complex(1, 1));

  ExpressionParser<Complex> parser = ComplexProcessor.createParser();
  System.out.println("(z^2)/(z/2):", parser.parse("(z^2)/(z/2)"));

ومحلل يتم تنفيذ نفسها في واحد <وأ href = "https://github.com/stefanhaustein/expressionparser/blob/master/src/main/java/org/kobjects/expressionparser/ExpressionParser.java" يختلط = "نوفولو"> جافا ملف دون التبعيات، وذلك لأغراض التقييم انها بسيطة لنسخ المشروع الخاص بك

Answer 4

وأود أن (ولها، في الواقع) يدويا عمل جدول تحليل واستخدام LR أو LALR بسيط محلل لمعالجة ذلك. في انخفاض، يمكنك تنفيذ العمليات الحسابية. ميزة واحدة لهذا هو أنه من السهل لتعديل "اللغة"، أو إدخال مقبول.

Answer 5

إليك الحل المجنون:تحتوي Java على محرك JavaScript مدمج (أفترض أنه يمكنك الوصول إليه من خلال المعالجة).الآن، تكتب فئة جافا سكريبت تعمل مع الأعداد المركبة (انسخها من هنا).ثم قم بتحميل عوامل الرياضيات بشكل زائد كما هو محدد هنا.بعد ذلك يمكنك فقط تقييم هذه السلسلة من Java.إنه أمر جنوني ولست متأكدًا من أنه سيعمل (لا أعرف جافا سكريبت).ربما سيكون من المفيد العثور على حل أبسط دون تحليل التعبيرات.

Answer 6

وهنا هو وجود صلة لمحلل التعبير الرياضيات مستقيم الى الامام (64 خطوط): <وأ href = "http://javadots.blogspot.com/2008/11/arithemetic-expressions-solver-in-64.html "يختلط =" noreferrer نوفولو "> http://javadots.blogspot.com/2008/11/arithemetic-expressions-solver-in-64.html

والتغيير والتبديل لدعم احتياجاتك لا ينبغي أن يكون من الصعب جدا

Answer 7

أباتشي الرياضيات المشتركة . فمن السهل جدا للاستخدام.

ويمكنك تهيئة كلا حقيقي + أجزاء وهمية. يمكنك أيضا تهيئة عليها من السلسلة. وهو يدعم مجموعة واسعة من العمليات التي يمكنك القيام به مع أرقام خيالية.

وهنا مثال من التعليمات البرمجية للقيام ببعض العمليات المشتركة:

package complex;
import static java.lang.String.format;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.complex.ComplexFormat;
public class Do 
{
    public static void main(String[] args) 
{
     ComplexFormat format = new ComplexFormat();
    Complex lhs = new Complex(1.0, 3.0);
    Complex rhs = new Complex(2.0, 5.0);

    Complex answer = lhs.add(rhs);       // add two complex numbers
    System.out.println("Add : "+ format.format(answer));
    answer = lhs.subtract(rhs);  // subtract two complex numbers
    System.out.println("Subtract : "+ format.format(answer));
    answer = lhs.conjugate();
    System.out.println("Conjgate : "+ format.format(answer));
    double d = lhs.abs();
    System.out.println("Absolute : "+d);
    Complex first  = new Complex(1.0, 3.0);
    Complex second = new Complex(2.0, 5.0);

    answer = first.log();        // natural logarithm.
            System.out.println("Logarithm : "+ format.format(answer));
    answer = first.cos();        // cosine
            System.out.println("Cosine : "+ format.format(answer));
    answer = first.pow(second);  // first raised to the power of second
            System.out.println("Power : "+ format.format(answer));

            Complex z = new Complex(2.0,2.0);
            Complex z1 = z.reciprocal();
            System.out.println("Recipocal : "+ format.format(z1));

            System.out.println("Absoltue of 2+2i is "+z.abs());
            System.out.println("Argument of 2+2i is "+z.getArgument());

    Complex r = new Complex(6.3,9.6);
    String conj = format.format(r.conjugate());
    String reci = format.format(r.reciprocal());

    System.out.println("Conjugate : "+conj+" Recipocal : "+reci);

    //answer = lhs.abs();          // absolute value
    //answer = lhs.conjugate(rhs); // complex conjugate

    //make complex to string

    ComplexFormat format = new ComplexFormat(); // default format
    Complex c = new Complex(1.1111, 2.2222);
    String s = format.format(c); // s contains "1.11 + 2.22i"
    System.out.println(s);

    //make string to complex

    String z = "2.5+3.6i";
    Complex e = format.parse(z);
    System.out.println(e);

}    
}

وثمة بديل آخر هو FrAid ، إذا كنت تريد خيار آخر.