/** {@inheritDoc} */ @Override public void allocPlus(int size) { this.result = F.PlusAlloc(size); }
@Override public void allocPlus(int size) { this.result = F.PlusAlloc(size); }
public void addOneIdentityPowerFactor(IExpr key, IAST subAST, Map<IExpr, IASTAppendable> map) { IASTAppendable resultList = map.get(key); if (resultList == null) { resultList = F.PlusAlloc(8); map.put(key, resultList); } resultList.appendOneIdentity(subAST); }
public void addPowerFactor(IExpr key, IExpr value, Map<IExpr, IASTAppendable> map) { IASTAppendable resultList = map.get(key); if (resultList == null) { resultList = F.PlusAlloc(8); map.put(key, resultList); } resultList.append(value); }
public IAST addToMap(final ISignedNumber key, final IExpr value) { IASTAppendable temp = map.get(key); if (temp == null) { temp = F.PlusAlloc(8); temp.append(value); map.put(key, temp); } else { temp.append(value); } return temp; }
public void reset() { int size = fListOfVariables.size(); this.fMatrixRow = F.ListAlloc(size); for (int i = 1; i < size; i++) { fMatrixRow.append(F.C0); } this.fPlusAST = F.PlusAlloc(8); this.fEquationType = LINEAR; }
public void reset() { this.row = F.ListAlloc(vars.size()); for (int i = 1; i < vars.size(); i++) { row.append(F.C0); } this.value = F.PlusAlloc(16); this.equationType = LINEAR; }
public IAST polyAlgebraicNumber2Expr(final GenPolynomial<AlgebraicNumber<BigRational>> poly) throws ArithmeticException, ClassCastException { if (poly.length() == 0) { return F.Plus(F.C0); } SortedMap<ExpVector, AlgebraicNumber<BigRational>> val = poly.getMap(); if (val.size() == 0) { return F.Plus(F.C0); } else { IASTAppendable result = F.PlusAlloc(val.size()); for (Map.Entry<ExpVector, AlgebraicNumber<BigRational>> m : val.entrySet()) { AlgebraicNumber<BigRational> coeff = m.getValue(); ExpVector exp = m.getKey(); IASTAppendable monomTimes = F.TimesAlloc(exp.length() + 1); monomialToExpr(coeff, exp, monomTimes); result.append(monomTimes.getOneIdentity(F.C1)); } return result; } }
private IExpr fromDigits(IAST list, IExpr radix) { IASTAppendable result = F.PlusAlloc(list.size()); int exp = 0; for (int i = list.size() - 1; i >= 1; i--) { result.append(list.get(i).abs().times(radix.power(exp++))); } return result; }
/** * Generates the Bell polynomial of the given index, where B(1) is 1. This is recursive. * * @param index * @return */ private static IExpr bellBPolynomial(int n, IExpr z) { if (n == 0) { return F.C1; } if (z.isZero()) { return F.C0; } if (n == 1) { return z; } IASTAppendable sum = F.PlusAlloc(n + 1); for (int k = 0; k <= n; k++) { sum.append(F.Times(F.StirlingS2(F.ZZ(n), F.ZZ(k)), F.Power(z, k))); } return sum; }
/** * Return <code>arg1 + (-1)*arg2</code> * * @param arg1 * @param arg2 * @return */ public static IAST Subtract(final IExpr arg1, final IExpr arg2) { if (arg1.isPlus()) { if (arg2.isZero()) { return (IAST) arg1; } IASTAppendable clone = F.PlusAlloc(arg1.size() + 1); clone.appendArgs((IAST) arg1); clone.append(binaryAST2(Times, CN1, arg2)); return clone; } return binaryAST2(Plus, arg1, binaryAST2(Times, CN1, arg2)); }
public IExpr e2ObjArg(final IExpr o0, final IExpr z) { int n = o0.toIntDefault(Integer.MIN_VALUE); if (n > 0 && z.isNumericFunction()) { // // Gamma(n,z) = ((n - 1)! * Sum(z^k/k!, {k, 0, n - 1}))/E^z // IASTAppendable sum = F.PlusAlloc(n); for (int k = 0; k < n; k++) { sum.append(F.Divide(F.Power(z, k), F.Factorial(F.ZZ(k)))); } return F.Times(F.Factorial(F.ZZ(n - 1)), sum, F.Power(E, z.negate())); } return F.NIL; }
/** * Convert a JAS integer polynomial to <code>IExpr</code>. * * @param poly * @return * @throws ArithmeticException * @throws ClassCastException */ public IExpr integerPoly2Expr(final GenPolynomial<edu.jas.arith.BigInteger> poly) throws ArithmeticException, ClassCastException { if (poly.length() == 0) { return F.C0; } IASTAppendable result = F.PlusAlloc(poly.length()); for (Monomial<edu.jas.arith.BigInteger> monomial : poly) { edu.jas.arith.BigInteger coeff = monomial.coefficient(); ExpVector exp = monomial.exponent(); IASTAppendable monomTimes = F.TimesAlloc(exp.length() + 1); monomialToExpr(coeff, exp, monomTimes); result.append(monomTimes.getOneIdentity(F.C1)); } return result.getOneIdentity(F.C0); }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); if ((ast.arg1().isVector() == ast.arg2().isVector()) && (ast.arg1().isVector() >= 0)) { IAST vector = (IAST) ast.arg1(); IAST variables = (IAST) ast.arg2(); int size = vector.size(); IASTAppendable divergenceValue = F.PlusAlloc(size); return divergenceValue.appendArgs(size, i -> F.D(vector.get(i), variables.get(i))); } return F.NIL; }
public IExpr modLongPoly2Expr(final GenPolynomial<ModLong> poly) throws ArithmeticException, ClassCastException { if (poly.length() == 0) { return F.Plus(F.C0); } IASTAppendable result = F.PlusAlloc(poly.length()); for (Monomial<ModLong> monomial : poly) { ModLong coeff = monomial.coefficient(); ExpVector exp = monomial.exponent(); IInteger coeffValue = F.integer(coeff.getVal()); IASTAppendable monomTimes = F.TimesAlloc(exp.length() + 1); monomialToExpr(coeffValue, exp, monomTimes); result.append(monomTimes.getOneIdentity(F.C1)); } return result.getOneIdentity(F.C0); }
/** * <code>Sin(a+b+c+...)</code> * * @param plusAST * @param startPosition * @return */ private static IExpr expandSinPlus(IAST plusAST, int startPosition) { IASTAppendable result = F.PlusAlloc(2); IExpr lhs = plusAST.get(startPosition); if (startPosition == plusAST.size() - 2) { IExpr rhs = plusAST.get(startPosition + 1); result.append(Times(Sin(lhs), Cos(rhs))); result.append(Times(Cos(lhs), Sin(rhs))); } else { result.append(Times(Sin(lhs), expandCosPlus(plusAST, startPosition + 1))); result.append(Times(Cos(lhs), expandSinPlus(plusAST, startPosition + 1))); } return result; }
/** * <code>Sin(a+b+c+...)</code> * * @param plusAST * @param startPosition * @return */ private static IExpr expandCosPlus(IAST plusAST, int startPosition) { IASTAppendable result = F.PlusAlloc(2); IExpr lhs = plusAST.get(startPosition); if (startPosition == plusAST.size() - 2) { IExpr rhs = plusAST.get(startPosition + 1); result.append(Times(Cos(lhs), Cos(rhs))); result.append(Times(CN1, Sin(lhs), Sin(rhs))); } else { result.append(Times(Cos(lhs), expandCosPlus(plusAST, startPosition + 1))); result.append(Times(CN1, Sin(lhs), expandSinPlus(plusAST, startPosition + 1))); } return result; }
/** * <code>Sinh(a+b+c+...)</code> * * @param plusAST * @param startPosition * @return */ private static IExpr expandSinhPlus(IAST plusAST, int startPosition) { IASTAppendable result = F.PlusAlloc(2); IExpr lhs = plusAST.get(startPosition); if (startPosition == plusAST.size() - 2) { // Sinh(x)*Cosh(y) + Cosh(x)*Sinh(y) IExpr rhs = plusAST.get(startPosition + 1); result.append(Times(F.Sinh(lhs), F.Cosh(rhs))); result.append(Times(F.Cosh(lhs), F.Sinh(rhs))); } else { result.append(Times(F.Sinh(lhs), expandCoshPlus(plusAST, startPosition + 1))); result.append(Times(F.Cosh(lhs), expandSinhPlus(plusAST, startPosition + 1))); } return result; }
/** * <code>Cosh(a+b+c+...)</code> * * @param plusAST * @param startPosition * @return */ private static IExpr expandCoshPlus(IAST plusAST, int startPosition) { IASTAppendable result = F.PlusAlloc(2); IExpr lhs = plusAST.get(startPosition); if (startPosition == plusAST.size() - 2) { // Cosh(x)*Cosh(y) + Sinh(x)*Sinh(y) IExpr rhs = plusAST.get(startPosition + 1); result.append(Times(F.Cosh(lhs), F.Cosh(rhs))); result.append(Times(F.Sinh(lhs), F.Sinh(rhs))); } else { result.append(Times(F.Cosh(lhs), expandCoshPlus(plusAST, startPosition + 1))); result.append(Times(F.Sinh(lhs), expandSinhPlus(plusAST, startPosition + 1))); } return result; }
public static IExpr vectorCovarianceSymbolic(final IAST arg1, final IAST arg2, int arg1Length) { if (arg1Length == 2) { return F.Times(F.C1D2, F.Subtract(arg1.arg1(), arg1.arg2()), F.Subtract(F.Conjugate(arg2.arg1()), F.Conjugate(arg2.arg2()))); } IAST num1 = arg1.apply(F.Plus); IExpr factor = F.integer(-1 * (arg1.size() - 2)); IASTAppendable v1 = F.PlusAlloc(arg1.size()); v1.appendArgs(arg1.size(), i -> F.Times(F.CN1, num1.setAtCopy(i, F.Times(factor, arg1.get(i))), F.Conjugate(arg2.get(i)))); return F.Divide(v1, F.integer(((long) arg1.argSize()) * (((long) arg1.size()) - 2L))); }