| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.calculator2; |
| |
| import android.content.Context; |
| import android.text.SpannableString; |
| import android.text.SpannableStringBuilder; |
| import android.text.Spanned; |
| import android.text.style.TtsSpan; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInput; |
| import java.io.DataOutput; |
| import java.io.DataOutputStream; |
| import java.io.IOException; |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| |
| /** |
| * A mathematical expression represented as a sequence of "tokens". |
| * Many tokens are represented by button ids for the corresponding operator. |
| * A token may also represent the result of a previously evaluated expression. |
| * The add() method adds a token to the end of the expression. The delete method() removes one. |
| * Clear() deletes the entire expression contents. Eval() evaluates the expression, |
| * producing a UnifiedReal result. |
| * Expressions are parsed only during evaluation; no explicit parse tree is maintained. |
| * |
| * The write() method is used to save the current expression. Note that neither UnifiedReal |
| * nor the underlying CR provide a serialization facility. Thus we save all previously |
| * computed values by writing out the expression that was used to compute them, and reevaluate |
| * when reading it back in. |
| */ |
| class CalculatorExpr { |
| /** |
| * An interface for resolving expression indices in embedded subexpressions to |
| * the associated CalculatorExpr, and associating a UnifiedReal result with it. |
| * All methods are thread-safe in the strong sense; they may be called asynchronously |
| * at any time from any thread. |
| */ |
| public interface ExprResolver { |
| /* |
| * Retrieve the expression corresponding to index. |
| */ |
| CalculatorExpr getExpr(long index); |
| /* |
| * Retrieve the degree mode associated with the expression at index i. |
| */ |
| boolean getDegreeMode(long index); |
| /* |
| * Retrieve the stored result for the expression at index, or return null. |
| */ |
| UnifiedReal getResult(long index); |
| /* |
| * Atomically test for an existing result, and set it if there was none. |
| * Return the prior result if there was one, or the new one if there was not. |
| * May only be called after getExpr. |
| */ |
| UnifiedReal putResultIfAbsent(long index, UnifiedReal result); |
| } |
| |
| private ArrayList<Token> mExpr; // The actual representation |
| // as a list of tokens. Constant |
| // tokens are always nonempty. |
| |
| private static enum TokenKind { CONSTANT, OPERATOR, PRE_EVAL }; |
| private static TokenKind[] tokenKindValues = TokenKind.values(); |
| private final static BigInteger BIG_MILLION = BigInteger.valueOf(1000000); |
| private final static BigInteger BIG_BILLION = BigInteger.valueOf(1000000000); |
| |
| private static abstract class Token { |
| abstract TokenKind kind(); |
| |
| /** |
| * Write token as either a very small Byte containing the TokenKind, |
| * followed by data needed by subclass constructor, |
| * or as a byte >= 0x20 directly describing the OPERATOR token. |
| */ |
| abstract void write(DataOutput out) throws IOException; |
| |
| /** |
| * Return a textual representation of the token. |
| * The result is suitable for either display as part od the formula or TalkBack use. |
| * It may be a SpannableString that includes added TalkBack information. |
| * @param context context used for converting button ids to strings |
| */ |
| abstract CharSequence toCharSequence(Context context); |
| } |
| |
| /** |
| * Representation of an operator token |
| */ |
| private static class Operator extends Token { |
| // TODO: rename id. |
| public final int id; // We use the button resource id |
| Operator(int resId) { |
| id = resId; |
| } |
| Operator(byte op) throws IOException { |
| id = KeyMaps.fromByte(op); |
| } |
| @Override |
| void write(DataOutput out) throws IOException { |
| out.writeByte(KeyMaps.toByte(id)); |
| } |
| @Override |
| public CharSequence toCharSequence(Context context) { |
| String desc = KeyMaps.toDescriptiveString(context, id); |
| if (desc != null) { |
| SpannableString result = new SpannableString(KeyMaps.toString(context, id)); |
| Object descSpan = new TtsSpan.TextBuilder(desc).build(); |
| result.setSpan(descSpan, 0, result.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); |
| return result; |
| } else { |
| return KeyMaps.toString(context, id); |
| } |
| } |
| @Override |
| TokenKind kind() { return TokenKind.OPERATOR; } |
| } |
| |
| /** |
| * Representation of a (possibly incomplete) numerical constant. |
| * Supports addition and removal of trailing characters; hence mutable. |
| */ |
| private static class Constant extends Token implements Cloneable { |
| private boolean mSawDecimal; |
| private String mWhole; // String preceding decimal point. |
| private String mFraction; // String after decimal point. |
| private int mExponent; // Explicit exponent, only generated through addExponent. |
| private static int SAW_DECIMAL = 0x1; |
| private static int HAS_EXPONENT = 0x2; |
| |
| Constant() { |
| mWhole = ""; |
| mFraction = ""; |
| // mSawDecimal = false; |
| // mExponent = 0; |
| }; |
| |
| Constant(DataInput in) throws IOException { |
| mWhole = in.readUTF(); |
| byte flags = in.readByte(); |
| if ((flags & SAW_DECIMAL) != 0) { |
| mSawDecimal = true; |
| mFraction = in.readUTF(); |
| } else { |
| // mSawDecimal = false; |
| mFraction = ""; |
| } |
| if ((flags & HAS_EXPONENT) != 0) { |
| mExponent = in.readInt(); |
| } |
| } |
| |
| @Override |
| void write(DataOutput out) throws IOException { |
| byte flags = (byte)((mSawDecimal ? SAW_DECIMAL : 0) |
| | (mExponent != 0 ? HAS_EXPONENT : 0)); |
| out.writeByte(TokenKind.CONSTANT.ordinal()); |
| out.writeUTF(mWhole); |
| out.writeByte(flags); |
| if (mSawDecimal) { |
| out.writeUTF(mFraction); |
| } |
| if (mExponent != 0) { |
| out.writeInt(mExponent); |
| } |
| } |
| |
| // Given a button press, append corresponding digit. |
| // We assume id is a digit or decimal point. |
| // Just return false if this was the second (or later) decimal point |
| // in this constant. |
| // Assumes that this constant does not have an exponent. |
| public boolean add(int id) { |
| if (id == R.id.dec_point) { |
| if (mSawDecimal || mExponent != 0) return false; |
| mSawDecimal = true; |
| return true; |
| } |
| int val = KeyMaps.digVal(id); |
| if (mExponent != 0) { |
| if (Math.abs(mExponent) <= 10000) { |
| if (mExponent > 0) { |
| mExponent = 10 * mExponent + val; |
| } else { |
| mExponent = 10 * mExponent - val; |
| } |
| return true; |
| } else { // Too large; refuse |
| return false; |
| } |
| } |
| if (mSawDecimal) { |
| mFraction += val; |
| } else { |
| mWhole += val; |
| } |
| return true; |
| } |
| |
| public void addExponent(int exp) { |
| // Note that adding a 0 exponent is a no-op. That's OK. |
| mExponent = exp; |
| } |
| |
| /** |
| * Undo the last add or remove last exponent digit. |
| * Assumes the constant is nonempty. |
| */ |
| public void delete() { |
| if (mExponent != 0) { |
| mExponent /= 10; |
| // Once zero, it can only be added back with addExponent. |
| } else if (!mFraction.isEmpty()) { |
| mFraction = mFraction.substring(0, mFraction.length() - 1); |
| } else if (mSawDecimal) { |
| mSawDecimal = false; |
| } else { |
| mWhole = mWhole.substring(0, mWhole.length() - 1); |
| } |
| } |
| |
| public boolean isEmpty() { |
| return (mSawDecimal == false && mWhole.isEmpty()); |
| } |
| |
| /** |
| * Produce human-readable string representation of constant, as typed. |
| * We do add digit grouping separators to the whole number, even if not typed. |
| * Result is internationalized. |
| */ |
| @Override |
| public String toString() { |
| String result; |
| if (mExponent != 0) { |
| result = mWhole; |
| } else { |
| result = StringUtils.addCommas(mWhole, 0, mWhole.length()); |
| } |
| if (mSawDecimal) { |
| result += '.'; |
| result += mFraction; |
| } |
| if (mExponent != 0) { |
| result += "E" + mExponent; |
| } |
| return KeyMaps.translateResult(result); |
| } |
| |
| /** |
| * Return BoundedRational representation of constant, if well-formed. |
| * Result is never null. |
| */ |
| public BoundedRational toRational() throws SyntaxException { |
| String whole = mWhole; |
| if (whole.isEmpty()) { |
| if (mFraction.isEmpty()) { |
| // Decimal point without digits. |
| throw new SyntaxException(); |
| } else { |
| whole = "0"; |
| } |
| } |
| BigInteger num = new BigInteger(whole + mFraction); |
| BigInteger den = BigInteger.TEN.pow(mFraction.length()); |
| if (mExponent > 0) { |
| num = num.multiply(BigInteger.TEN.pow(mExponent)); |
| } |
| if (mExponent < 0) { |
| den = den.multiply(BigInteger.TEN.pow(-mExponent)); |
| } |
| return new BoundedRational(num, den); |
| } |
| |
| @Override |
| public CharSequence toCharSequence(Context context) { |
| return toString(); |
| } |
| |
| @Override |
| public TokenKind kind() { |
| return TokenKind.CONSTANT; |
| } |
| |
| // Override clone to make it public |
| @Override |
| public Object clone() { |
| Constant result = new Constant(); |
| result.mWhole = mWhole; |
| result.mFraction = mFraction; |
| result.mSawDecimal = mSawDecimal; |
| result.mExponent = mExponent; |
| return result; |
| } |
| } |
| |
| /** |
| * The "token" class for previously evaluated subexpressions. |
| * We treat previously evaluated subexpressions as tokens. These are inserted when we either |
| * continue an expression after evaluating some of it, or copy an expression and paste it back |
| * in. |
| * This only contains enough information to allow us to display the expression in a |
| * formula, or reevaluate the expression with the aid of an ExprResolver; we no longer |
| * cache the result. The expression corresponding to the index can be obtained through |
| * the ExprResolver, which looks it up in a subexpression database. |
| * The representation includes a UnifiedReal value. In order to |
| * support saving and restoring, we also include the underlying expression itself, and the |
| * context (currently just degree mode) used to evaluate it. The short string representation |
| * is also stored in order to avoid potentially expensive recomputation in the UI thread. |
| */ |
| private static class PreEval extends Token { |
| public final long mIndex; |
| private final String mShortRep; // Not internationalized. |
| PreEval(long index, String shortRep) { |
| mIndex = index; |
| mShortRep = shortRep; |
| } |
| @Override |
| // This writes out only a shallow representation of the result, without |
| // information about subexpressions. To write out a deep representation, we |
| // find referenced subexpressions, and iteratively write those as well. |
| public void write(DataOutput out) throws IOException { |
| out.writeByte(TokenKind.PRE_EVAL.ordinal()); |
| if (mIndex > Integer.MAX_VALUE || mIndex < Integer.MIN_VALUE) { |
| // This would be millions of expressions per day for the life of the device. |
| throw new AssertionError("Expression index too big"); |
| } |
| out.writeInt((int)mIndex); |
| out.writeUTF(mShortRep); |
| } |
| PreEval(DataInput in) throws IOException { |
| mIndex = in.readInt(); |
| mShortRep = in.readUTF(); |
| } |
| @Override |
| public CharSequence toCharSequence(Context context) { |
| return KeyMaps.translateResult(mShortRep); |
| } |
| @Override |
| public TokenKind kind() { |
| return TokenKind.PRE_EVAL; |
| } |
| public boolean hasEllipsis() { |
| return mShortRep.lastIndexOf(KeyMaps.ELLIPSIS) != -1; |
| } |
| } |
| |
| /** |
| * Read token from in. |
| */ |
| public static Token newToken(DataInput in) throws IOException { |
| byte kindByte = in.readByte(); |
| if (kindByte < 0x20) { |
| TokenKind kind = tokenKindValues[kindByte]; |
| switch(kind) { |
| case CONSTANT: |
| return new Constant(in); |
| case PRE_EVAL: |
| PreEval pe = new PreEval(in); |
| if (pe.mIndex == -1) { |
| // Database corrupted by earlier bug. |
| // Return a conspicuously wrong placeholder that won't lead to a crash. |
| Constant result = new Constant(); |
| result.add(R.id.dec_point); |
| return result; |
| } else { |
| return pe; |
| } |
| default: throw new IOException("Bad save file format"); |
| } |
| } else { |
| return new Operator(kindByte); |
| } |
| } |
| |
| CalculatorExpr() { |
| mExpr = new ArrayList<Token>(); |
| } |
| |
| private CalculatorExpr(ArrayList<Token> expr) { |
| mExpr = expr; |
| } |
| |
| /** |
| * Construct CalculatorExpr, by reading it from in. |
| */ |
| CalculatorExpr(DataInput in) throws IOException { |
| mExpr = new ArrayList<Token>(); |
| int size = in.readInt(); |
| for (int i = 0; i < size; ++i) { |
| mExpr.add(newToken(in)); |
| } |
| } |
| |
| /** |
| * Write this expression to out. |
| */ |
| public void write(DataOutput out) throws IOException { |
| int size = mExpr.size(); |
| out.writeInt(size); |
| for (int i = 0; i < size; ++i) { |
| mExpr.get(i).write(out); |
| } |
| } |
| |
| /** |
| * Use write() above to generate a byte array containing a serialized representation of |
| * this expression. |
| */ |
| public byte[] toBytes() { |
| ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream(); |
| try (DataOutputStream out = new DataOutputStream(byteArrayStream)) { |
| write(out); |
| } catch (IOException e) { |
| // Impossible; No IO involved. |
| throw new AssertionError("Impossible IO exception", e); |
| } |
| return byteArrayStream.toByteArray(); |
| } |
| |
| /** |
| * Does this expression end with a numeric constant? |
| * As opposed to an operator or preevaluated expression. |
| */ |
| boolean hasTrailingConstant() { |
| int s = mExpr.size(); |
| if (s == 0) { |
| return false; |
| } |
| Token t = mExpr.get(s-1); |
| return t instanceof Constant; |
| } |
| |
| /** |
| * Does this expression end with a binary operator? |
| */ |
| boolean hasTrailingBinary() { |
| int s = mExpr.size(); |
| if (s == 0) return false; |
| Token t = mExpr.get(s-1); |
| if (!(t instanceof Operator)) return false; |
| Operator o = (Operator)t; |
| return (KeyMaps.isBinary(o.id)); |
| } |
| |
| /** |
| * Append press of button with given id to expression. |
| * If the insertion would clearly result in a syntax error, either just return false |
| * and do nothing, or make an adjustment to avoid the problem. We do the latter only |
| * for unambiguous consecutive binary operators, in which case we delete the first |
| * operator. |
| */ |
| boolean add(int id) { |
| int s = mExpr.size(); |
| final int d = KeyMaps.digVal(id); |
| final boolean binary = KeyMaps.isBinary(id); |
| Token lastTok = s == 0 ? null : mExpr.get(s-1); |
| int lastOp = lastTok instanceof Operator ? ((Operator) lastTok).id : 0; |
| // Quietly replace a trailing binary operator with another one, unless the second |
| // operator is minus, in which case we just allow it as a unary minus. |
| if (binary && !KeyMaps.isPrefix(id)) { |
| if (s == 0 || lastOp == R.id.lparen || KeyMaps.isFunc(lastOp) |
| || KeyMaps.isPrefix(lastOp) && lastOp != R.id.op_sub) { |
| return false; |
| } |
| while (hasTrailingBinary()) { |
| delete(); |
| } |
| // s invalid and not used below. |
| } |
| final boolean isConstPiece = (d != KeyMaps.NOT_DIGIT || id == R.id.dec_point); |
| if (isConstPiece) { |
| // Since we treat juxtaposition as multiplication, a constant can appear anywhere. |
| if (s == 0) { |
| mExpr.add(new Constant()); |
| s++; |
| } else { |
| Token last = mExpr.get(s-1); |
| if(!(last instanceof Constant)) { |
| if (last instanceof PreEval) { |
| // Add explicit multiplication to avoid confusing display. |
| mExpr.add(new Operator(R.id.op_mul)); |
| s++; |
| } |
| mExpr.add(new Constant()); |
| s++; |
| } |
| } |
| return ((Constant)(mExpr.get(s-1))).add(id); |
| } else { |
| mExpr.add(new Operator(id)); |
| return true; |
| } |
| } |
| |
| /** |
| * Add exponent to the constant at the end of the expression. |
| * Assumes there is a constant at the end of the expression. |
| */ |
| void addExponent(int exp) { |
| Token lastTok = mExpr.get(mExpr.size() - 1); |
| ((Constant) lastTok).addExponent(exp); |
| } |
| |
| /** |
| * Remove trailing op_add and op_sub operators. |
| */ |
| void removeTrailingAdditiveOperators() { |
| while (true) { |
| int s = mExpr.size(); |
| if (s == 0) { |
| break; |
| } |
| Token lastTok = mExpr.get(s-1); |
| if (!(lastTok instanceof Operator)) { |
| break; |
| } |
| int lastOp = ((Operator) lastTok).id; |
| if (lastOp != R.id.op_add && lastOp != R.id.op_sub) { |
| break; |
| } |
| delete(); |
| } |
| } |
| |
| /** |
| * Append the contents of the argument expression. |
| * It is assumed that the argument expression will not change, and thus its pieces can be |
| * reused directly. |
| */ |
| public void append(CalculatorExpr expr2) { |
| int s = mExpr.size(); |
| int s2 = expr2.mExpr.size(); |
| // Check that we're not concatenating Constant or PreEval tokens, since the result would |
| // look like a single constant, with very mysterious results for the user. |
| if (s != 0 && s2 != 0) { |
| Token last = mExpr.get(s-1); |
| Token first = expr2.mExpr.get(0); |
| if (!(first instanceof Operator) && !(last instanceof Operator)) { |
| // Fudge it by adding an explicit multiplication. We would have interpreted it as |
| // such anyway, and this makes it recognizable to the user. |
| mExpr.add(new Operator(R.id.op_mul)); |
| } |
| } |
| for (int i = 0; i < s2; ++i) { |
| mExpr.add(expr2.mExpr.get(i)); |
| } |
| } |
| |
| /** |
| * Undo the last key addition, if any. |
| * Or possibly remove a trailing exponent digit. |
| */ |
| public void delete() { |
| final int s = mExpr.size(); |
| if (s == 0) { |
| return; |
| } |
| Token last = mExpr.get(s-1); |
| if (last instanceof Constant) { |
| Constant c = (Constant)last; |
| c.delete(); |
| if (!c.isEmpty()) { |
| return; |
| } |
| } |
| mExpr.remove(s-1); |
| } |
| |
| /** |
| * Remove all tokens from the expression. |
| */ |
| public void clear() { |
| mExpr.clear(); |
| } |
| |
| public boolean isEmpty() { |
| return mExpr.isEmpty(); |
| } |
| |
| /** |
| * Returns a logical deep copy of the CalculatorExpr. |
| * Operator and PreEval tokens are immutable, and thus aren't really copied. |
| */ |
| public Object clone() { |
| CalculatorExpr result = new CalculatorExpr(); |
| for (Token t : mExpr) { |
| if (t instanceof Constant) { |
| result.mExpr.add((Token)(((Constant)t).clone())); |
| } else { |
| result.mExpr.add(t); |
| } |
| } |
| return result; |
| } |
| |
| // Am I just a constant? |
| public boolean isConstant() { |
| if (mExpr.size() != 1) { |
| return false; |
| } |
| return mExpr.get(0) instanceof Constant; |
| } |
| |
| /** |
| * Return a new expression consisting of a single token representing the current pre-evaluated |
| * expression. |
| * The caller supplies the expression index and short string representation. |
| * The expression must have been previously evaluated. |
| */ |
| public CalculatorExpr abbreviate(long index, String sr) { |
| CalculatorExpr result = new CalculatorExpr(); |
| @SuppressWarnings("unchecked") |
| Token t = new PreEval(index, sr); |
| result.mExpr.add(t); |
| return result; |
| } |
| |
| /** |
| * Internal evaluation functions return an EvalRet pair. |
| * We compute rational (BoundedRational) results when possible, both as a performance |
| * optimization, and to detect errors exactly when we can. |
| */ |
| private static class EvalRet { |
| public int pos; // Next position (expression index) to be parsed. |
| public final UnifiedReal val; // Constructive Real result of evaluating subexpression. |
| EvalRet(int p, UnifiedReal v) { |
| pos = p; |
| val = v; |
| } |
| } |
| |
| /** |
| * Internal evaluation functions take an EvalContext argument. |
| */ |
| private static class EvalContext { |
| public final int mPrefixLength; // Length of prefix to evaluate. Not explicitly saved. |
| public final boolean mDegreeMode; |
| public final ExprResolver mExprResolver; // Reconstructed, not saved. |
| // If we add any other kinds of evaluation modes, they go here. |
| EvalContext(boolean degreeMode, int len, ExprResolver er) { |
| mDegreeMode = degreeMode; |
| mPrefixLength = len; |
| mExprResolver = er; |
| } |
| EvalContext(DataInput in, int len, ExprResolver er) throws IOException { |
| mDegreeMode = in.readBoolean(); |
| mPrefixLength = len; |
| mExprResolver = er; |
| } |
| void write(DataOutput out) throws IOException { |
| out.writeBoolean(mDegreeMode); |
| } |
| } |
| |
| private UnifiedReal toRadians(UnifiedReal x, EvalContext ec) { |
| if (ec.mDegreeMode) { |
| return x.multiply(UnifiedReal.RADIANS_PER_DEGREE); |
| } else { |
| return x; |
| } |
| } |
| |
| private UnifiedReal fromRadians(UnifiedReal x, EvalContext ec) { |
| if (ec.mDegreeMode) { |
| return x.divide(UnifiedReal.RADIANS_PER_DEGREE); |
| } else { |
| return x; |
| } |
| } |
| |
| // The following methods can all throw IndexOutOfBoundsException in the event of a syntax |
| // error. We expect that to be caught in eval below. |
| |
| private boolean isOperatorUnchecked(int i, int op) { |
| Token t = mExpr.get(i); |
| if (!(t instanceof Operator)) { |
| return false; |
| } |
| return ((Operator)(t)).id == op; |
| } |
| |
| private boolean isOperator(int i, int op, EvalContext ec) { |
| if (i >= ec.mPrefixLength) { |
| return false; |
| } |
| return isOperatorUnchecked(i, op); |
| } |
| |
| public static class SyntaxException extends Exception { |
| public SyntaxException() { |
| super(); |
| } |
| public SyntaxException(String s) { |
| super(s); |
| } |
| } |
| |
| // The following functions all evaluate some kind of expression starting at position i in |
| // mExpr in a specified evaluation context. They return both the expression value (as |
| // constructive real and, if applicable, as BoundedRational) and the position of the next token |
| // that was not used as part of the evaluation. |
| // This is essentially a simple recursive descent parser combined with expression evaluation. |
| |
| private EvalRet evalUnary(int i, EvalContext ec) throws SyntaxException { |
| final Token t = mExpr.get(i); |
| if (t instanceof Constant) { |
| Constant c = (Constant)t; |
| return new EvalRet(i+1,new UnifiedReal(c.toRational())); |
| } |
| if (t instanceof PreEval) { |
| final long index = ((PreEval)t).mIndex; |
| UnifiedReal res = ec.mExprResolver.getResult(index); |
| if (res == null) { |
| // We try to minimize this recursive evaluation case, but currently don't |
| // completely avoid it. |
| res = nestedEval(index, ec.mExprResolver); |
| } |
| return new EvalRet(i+1, res); |
| } |
| EvalRet argVal; |
| switch(((Operator)(t)).id) { |
| case R.id.const_pi: |
| return new EvalRet(i+1, UnifiedReal.PI); |
| case R.id.const_e: |
| return new EvalRet(i+1, UnifiedReal.E); |
| case R.id.op_sqrt: |
| // Seems to have highest precedence. |
| // Does not add implicit paren. |
| // Does seem to accept a leading minus. |
| if (isOperator(i+1, R.id.op_sub, ec)) { |
| argVal = evalUnary(i+2, ec); |
| return new EvalRet(argVal.pos, argVal.val.negate().sqrt()); |
| } else { |
| argVal = evalUnary(i+1, ec); |
| return new EvalRet(argVal.pos, argVal.val.sqrt()); |
| } |
| case R.id.lparen: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, argVal.val); |
| case R.id.fun_sin: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, toRadians(argVal.val, ec).sin()); |
| case R.id.fun_cos: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, toRadians(argVal.val,ec).cos()); |
| case R.id.fun_tan: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| UnifiedReal arg = toRadians(argVal.val, ec); |
| return new EvalRet(argVal.pos, arg.sin().divide(arg.cos())); |
| case R.id.fun_ln: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, argVal.val.ln()); |
| case R.id.fun_exp: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, argVal.val.exp()); |
| case R.id.fun_log: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, argVal.val.ln().divide(UnifiedReal.TEN.ln())); |
| case R.id.fun_arcsin: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, fromRadians(argVal.val.asin(), ec)); |
| case R.id.fun_arccos: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, fromRadians(argVal.val.acos(), ec)); |
| case R.id.fun_arctan: |
| argVal = evalExpr(i+1, ec); |
| if (isOperator(argVal.pos, R.id.rparen, ec)) { |
| argVal.pos++; |
| } |
| return new EvalRet(argVal.pos, fromRadians(argVal.val.atan(),ec)); |
| default: |
| throw new SyntaxException("Unrecognized token in expression"); |
| } |
| } |
| |
| private static final UnifiedReal ONE_HUNDREDTH = new UnifiedReal(100).inverse(); |
| |
| private EvalRet evalSuffix(int i, EvalContext ec) throws SyntaxException { |
| final EvalRet tmp = evalUnary(i, ec); |
| int cpos = tmp.pos; |
| UnifiedReal val = tmp.val; |
| |
| boolean isFact; |
| boolean isSquared = false; |
| while ((isFact = isOperator(cpos, R.id.op_fact, ec)) || |
| (isSquared = isOperator(cpos, R.id.op_sqr, ec)) || |
| isOperator(cpos, R.id.op_pct, ec)) { |
| if (isFact) { |
| val = val.fact(); |
| } else if (isSquared) { |
| val = val.multiply(val); |
| } else /* percent */ { |
| val = val.multiply(ONE_HUNDREDTH); |
| } |
| ++cpos; |
| } |
| return new EvalRet(cpos, val); |
| } |
| |
| private EvalRet evalFactor(int i, EvalContext ec) throws SyntaxException { |
| final EvalRet result1 = evalSuffix(i, ec); |
| int cpos = result1.pos; // current position |
| UnifiedReal val = result1.val; // value so far |
| if (isOperator(cpos, R.id.op_pow, ec)) { |
| final EvalRet exp = evalSignedFactor(cpos + 1, ec); |
| cpos = exp.pos; |
| val = val.pow(exp.val); |
| } |
| return new EvalRet(cpos, val); |
| } |
| |
| private EvalRet evalSignedFactor(int i, EvalContext ec) throws SyntaxException { |
| final boolean negative = isOperator(i, R.id.op_sub, ec); |
| int cpos = negative ? i + 1 : i; |
| EvalRet tmp = evalFactor(cpos, ec); |
| cpos = tmp.pos; |
| final UnifiedReal result = negative ? tmp.val.negate() : tmp.val; |
| return new EvalRet(cpos, result); |
| } |
| |
| private boolean canStartFactor(int i) { |
| if (i >= mExpr.size()) return false; |
| Token t = mExpr.get(i); |
| if (!(t instanceof Operator)) return true; |
| int id = ((Operator)(t)).id; |
| if (KeyMaps.isBinary(id)) return false; |
| switch (id) { |
| case R.id.op_fact: |
| case R.id.rparen: |
| return false; |
| default: |
| return true; |
| } |
| } |
| |
| private EvalRet evalTerm(int i, EvalContext ec) throws SyntaxException { |
| EvalRet tmp = evalSignedFactor(i, ec); |
| boolean is_mul = false; |
| boolean is_div = false; |
| int cpos = tmp.pos; // Current position in expression. |
| UnifiedReal val = tmp.val; // Current value. |
| while ((is_mul = isOperator(cpos, R.id.op_mul, ec)) |
| || (is_div = isOperator(cpos, R.id.op_div, ec)) |
| || canStartFactor(cpos)) { |
| if (is_mul || is_div) ++cpos; |
| tmp = evalSignedFactor(cpos, ec); |
| if (is_div) { |
| val = val.divide(tmp.val); |
| } else { |
| val = val.multiply(tmp.val); |
| } |
| cpos = tmp.pos; |
| is_mul = is_div = false; |
| } |
| return new EvalRet(cpos, val); |
| } |
| |
| /** |
| * Is the subexpression starting at pos a simple percent constant? |
| * This is used to recognize exppressions like 200+10%, which we handle specially. |
| * This is defined as a Constant or PreEval token, followed by a percent sign, and followed |
| * by either nothing or an additive operator. |
| * Note that we are intentionally far more restrictive in recognizing such expressions than |
| * e.g. http://blogs.msdn.com/b/oldnewthing/archive/2008/01/10/7047497.aspx . |
| * When in doubt, we fall back to the the naive interpretation of % as 1/100. |
| * Note that 100+(10)% yields 100.1 while 100+10% yields 110. This may be controversial, |
| * but is consistent with Google web search. |
| */ |
| private boolean isPercent(int pos) { |
| if (mExpr.size() < pos + 2 || !isOperatorUnchecked(pos + 1, R.id.op_pct)) { |
| return false; |
| } |
| Token number = mExpr.get(pos); |
| if (number instanceof Operator) { |
| return false; |
| } |
| if (mExpr.size() == pos + 2) { |
| return true; |
| } |
| if (!(mExpr.get(pos + 2) instanceof Operator)) { |
| return false; |
| } |
| Operator op = (Operator) mExpr.get(pos + 2); |
| return op.id == R.id.op_add || op.id == R.id.op_sub || op.id == R.id.rparen; |
| } |
| |
| /** |
| * Compute the multiplicative factor corresponding to an N% addition or subtraction. |
| * @param pos position of Constant or PreEval expression token corresponding to N. |
| * @param isSubtraction this is a subtraction, as opposed to addition. |
| * @param ec usable evaluation contex; only length matters. |
| * @return UnifiedReal value and position, which is pos + 2, i.e. after percent sign |
| */ |
| private EvalRet getPercentFactor(int pos, boolean isSubtraction, EvalContext ec) |
| throws SyntaxException { |
| EvalRet tmp = evalUnary(pos, ec); |
| UnifiedReal val = isSubtraction ? tmp.val.negate() : tmp.val; |
| val = UnifiedReal.ONE.add(val.multiply(ONE_HUNDREDTH)); |
| return new EvalRet(pos + 2 /* after percent sign */, val); |
| } |
| |
| private EvalRet evalExpr(int i, EvalContext ec) throws SyntaxException { |
| EvalRet tmp = evalTerm(i, ec); |
| boolean is_plus; |
| int cpos = tmp.pos; |
| UnifiedReal val = tmp.val; |
| while ((is_plus = isOperator(cpos, R.id.op_add, ec)) |
| || isOperator(cpos, R.id.op_sub, ec)) { |
| if (isPercent(cpos + 1)) { |
| tmp = getPercentFactor(cpos + 1, !is_plus, ec); |
| val = val.multiply(tmp.val); |
| } else { |
| tmp = evalTerm(cpos + 1, ec); |
| if (is_plus) { |
| val = val.add(tmp.val); |
| } else { |
| val = val.subtract(tmp.val); |
| } |
| } |
| cpos = tmp.pos; |
| } |
| return new EvalRet(cpos, val); |
| } |
| |
| /** |
| * Return the starting position of the sequence of trailing binary operators. |
| */ |
| private int trailingBinaryOpsStart() { |
| int result = mExpr.size(); |
| while (result > 0) { |
| Token last = mExpr.get(result - 1); |
| if (!(last instanceof Operator)) break; |
| Operator o = (Operator)last; |
| if (!KeyMaps.isBinary(o.id)) break; |
| --result; |
| } |
| return result; |
| } |
| |
| /** |
| * Is the current expression worth evaluating? |
| */ |
| public boolean hasInterestingOps() { |
| final int last = trailingBinaryOpsStart(); |
| int first = 0; |
| if (last > first && isOperatorUnchecked(first, R.id.op_sub)) { |
| // Leading minus is not by itself interesting. |
| first++; |
| } |
| for (int i = first; i < last; ++i) { |
| Token t1 = mExpr.get(i); |
| if (t1 instanceof Operator |
| || t1 instanceof PreEval && ((PreEval)t1).hasEllipsis()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Does the expression contain trig operations? |
| */ |
| public boolean hasTrigFuncs() { |
| for (Token t : mExpr) { |
| if (t instanceof Operator) { |
| Operator o = (Operator)t; |
| if (KeyMaps.isTrigFunc(o.id)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Add the indices of unevaluated PreEval expressions embedded in the current expression to |
| * argument. This includes only directly referenced expressions e, not those indirectly |
| * referenced by e. If the index was already present, it is not added. If the argument |
| * contained no duplicates, the result will not either. New indices are added to the end of |
| * the list. |
| */ |
| private void addReferencedExprs(ArrayList<Long> list, ExprResolver er) { |
| for (Token t : mExpr) { |
| if (t instanceof PreEval) { |
| Long index = ((PreEval) t).mIndex; |
| if (er.getResult(index) == null && !list.contains(index)) { |
| list.add(index); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Return a list of unevaluated expressions transitively referenced by the current one. |
| * All expressions in the resulting list will have had er.getExpr() called on them. |
| * The resulting list is ordered such that evaluating expressions in list order |
| * should trigger few recursive evaluations. |
| */ |
| public ArrayList<Long> getTransitivelyReferencedExprs(ExprResolver er) { |
| // We could avoid triggering any recursive evaluations by actually building the |
| // dependency graph and topologically sorting it. Note that sorting by index works |
| // for positive and negative indices separately, but not their union. Currently we |
| // just settle for reverse breadth-first-search order, which handles the common case |
| // of simple dependency chains well. |
| ArrayList<Long> list = new ArrayList<Long>(); |
| int scanned = 0; // We've added expressions referenced by [0, scanned) to the list |
| addReferencedExprs(list, er); |
| while (scanned != list.size()) { |
| er.getExpr(list.get(scanned++)).addReferencedExprs(list, er); |
| } |
| Collections.reverse(list); |
| return list; |
| } |
| |
| /** |
| * Evaluate the expression at the given index to a UnifiedReal. |
| * Both saves and returns the result. |
| */ |
| UnifiedReal nestedEval(long index, ExprResolver er) throws SyntaxException { |
| CalculatorExpr nestedExpr = er.getExpr(index); |
| EvalContext newEc = new EvalContext(er.getDegreeMode(index), |
| nestedExpr.trailingBinaryOpsStart(), er); |
| EvalRet new_res = nestedExpr.evalExpr(0, newEc); |
| return er.putResultIfAbsent(index, new_res.val); |
| } |
| |
| /** |
| * Evaluate the expression excluding trailing binary operators. |
| * Errors result in exceptions, most of which are unchecked. Should not be called |
| * concurrently with modification of the expression. May take a very long time; avoid calling |
| * from UI thread. |
| * |
| * @param degreeMode use degrees rather than radians |
| */ |
| UnifiedReal eval(boolean degreeMode, ExprResolver er) throws SyntaxException |
| // And unchecked exceptions thrown by UnifiedReal, CR, |
| // and BoundedRational. |
| { |
| // First evaluate all indirectly referenced expressions in increasing index order. |
| // This ensures that subsequent evaluation never encounters an embedded PreEval |
| // expression that has not been previously evaluated. |
| // We could do the embedded evaluations recursively, but that risks running out of |
| // stack space. |
| ArrayList<Long> referenced = getTransitivelyReferencedExprs(er); |
| for (long index : referenced) { |
| nestedEval(index, er); |
| } |
| try { |
| // We currently never include trailing binary operators, but include other trailing |
| // operators. Thus we usually, but not always, display results for prefixes of valid |
| // expressions, and don't generate an error where we previously displayed an instant |
| // result. This reflects the Android L design. |
| int prefixLen = trailingBinaryOpsStart(); |
| EvalContext ec = new EvalContext(degreeMode, prefixLen, er); |
| EvalRet res = evalExpr(0, ec); |
| if (res.pos != prefixLen) { |
| throw new SyntaxException("Failed to parse full expression"); |
| } |
| return res.val; |
| } catch (IndexOutOfBoundsException e) { |
| throw new SyntaxException("Unexpected expression end"); |
| } |
| } |
| |
| // Produce a string representation of the expression itself |
| SpannableStringBuilder toSpannableStringBuilder(Context context) { |
| SpannableStringBuilder ssb = new SpannableStringBuilder(); |
| for (Token t : mExpr) { |
| ssb.append(t.toCharSequence(context)); |
| } |
| return ssb; |
| } |
| } |
