public IExpr e2ObjArg(final IExpr o0, final IExpr o1) { if (o1.isZero()) { EvalEngine.get().printMessage("Quotient: division by zero"); return F.CComplexInfinity; } if (o0.isInteger() && o1.isInteger()) { return ((IInteger) o0).quotient((IInteger) o1); } if (o0.isReal() && o1.isReal()) { return F.Floor(((ISignedNumber) o0).divideBy((ISignedNumber) o1)); } if (o0.isRealResult() && o1.isRealResult()) { return F.Floor(F.num(o0.evalDouble() / o1.evalDouble())); } if (o0.isNumericFunction() && o1.isNumericFunction()) { return F.Floor(F.complexNum(o0.evalComplex().divide(o1.evalComplex()))); } return F.NIL; }
/** * Returns the largest (closest to positive infinity) <code>ISignedNumber</code> value that is not greater than * <code>this</code> and is equal to a mathematical integer. * * See <a href="http://en.wikipedia.org/wiki/Floor_and_ceiling_functions">Wikipedia - Floor and ceiling * functions</a> */ @Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkRange(ast, 2, 3); try { if (ast.isAST2()) { return F.Times(F.Floor(F.Divide(ast.arg1(), ast.arg2())), ast.arg2()); } IExpr arg1 = engine.evaluateNull(ast.arg1()); if (arg1.isPresent()) { return evalFloor(arg1).orElse(F.Floor(arg1)); } return evalFloor(ast.arg1()); } catch (ArithmeticException ae) { // ISignedNumber#floor() may throw ArithmeticException } return F.NIL; }
@Override public IExpr cdf(IAST dist, IExpr k) { if (dist.isAST1()) { IExpr p = dist.arg1(); // IExpr function = // [$ Piecewise({{GammaRegularized(1 + Floor(#), p), # >= 0}}, 0) & $] F.Function(F.Piecewise(F.List(F.List(F.GammaRegularized(F.Plus(F.C1, F.Floor(F.Slot1)), p), F.GreaterEqual(F.Slot1, F.C0))), F.C0)); // $$; return callFunction(function, k); } return F.NIL; }
@Override public IExpr cdf(IAST dist, IExpr k) { if (dist.isAST2()) { IExpr n = dist.arg1(); IExpr m = dist.arg2(); IExpr function = // [$ (Piecewise({{BetaRegularized(1 - m, n - Floor(#), 1 + Floor(#)), 0<=#<n}, {1, # >= n}}, // 0)) & $] F.Function(F.Piecewise(F.List( F.List(F.BetaRegularized(F.Plus(F.C1, F.Negate(m)), F.Plus(n, F.Negate(F.Floor(F.Slot1))), F.Plus(F.C1, F.Floor(F.Slot1))), F.And(F.LessEqual(F.C0, F.Slot1), F.Less(F.Slot1, n))), F.List(F.C1, F.GreaterEqual(F.Slot1, n))), F.C0)); // $$; return callFunction(function, k); } return F.NIL; }
F.Factorial(F.Plus(F.Negate(ns), nt)), F.Power(F.Times(F.Binomial(nt, n), F.Factorial(F.Plus(F.CN1, n, F.Negate(F.Floor(F.Slot1)))), F.Factorial(F.Plus(F.CN1, ns, F.Negate(F.Floor(F.Slot1))))), -1), F.HypergeometricPFQRegularized( F.List(F.C1, F.Plus(F.C1, F.Negate(n), F.Floor(F.Slot1)), F.Plus(F.C1, F.Negate(ns), F.Floor(F.Slot1))), F.List(F.Plus(F.C2, F.Floor(F.Slot1)), F.Plus(F.C2, F.Negate(n), F.Negate(ns), nt, F.Floor(F.Slot1))), F.C1))), F.And(F.LessEqual(F.C0, F.Slot1),
private IExpr power(IExpr x1, IExpr z) { // Power[x_ ^ y_, z_] :> x ^(y*z) IExpr base = x1.base(); IExpr exponent = x1.exponent(); IAST powerResult = Power(base, Times(exponent, z)); if (assumptions) { IAST floorResult = Floor(Divide(Subtract(Pi, Im(Times(exponent, Log(base)))), Times(C2, Pi))); IAST expResult = Power(E, Times(C2, I, Pi, z, floorResult)); IAST timesResult = Times(powerResult, expResult); return timesResult; } return powerResult; } }
/** * * See: <a href="http://en.wikipedia.org/wiki/Modular_arithmetic">Wikipedia - Modular arithmetic</a> */ public IExpr e2ObjArg(final IExpr o0, final IExpr o1) { if (o1.isZero()) { EvalEngine.get().printMessage("Mod: Modulus 0 encountered"); return F.Indeterminate; } if (o0.isInteger() && o1.isInteger()) { final IInteger i0 = (IInteger) o0; final IInteger i1 = (IInteger) o1; if (i1.isNegative()) { return i0.negate().mod(i1.negate()).negate(); } return i0.mod(i1); } if (o0.isReal() && o1.isReal()) { return F.Subtract(o0, F.Times(o1, F.Floor(((ISignedNumber) o0).divideBy((ISignedNumber) o1)))); } if (o0.isRealResult() && o1.isRealResult()) { return F.Subtract(o0, F.Times(o1, F.Floor(F.num(o0.evalDouble() / o1.evalDouble())))); } if (o0.isNumericFunction() && o1.isNumericFunction()) { return F.Subtract(o0, F.Times(o1, F.Floor(F.complexNum(o0.evalComplex().divide(o1.evalComplex()))))); } return F.NIL; }
@Override public IExpr cdf(IAST dist, IExpr k) { if (dist.isAST1()) { IExpr n = dist.arg1(); IExpr function = // [$ (Piecewise({{1 - (1 - n)^(1 + Floor(#)), # >= 0}}, 0)) & $] F.Function( F.Piecewise(F.List(F.List( F.Plus(F.C1, F.Negate(F.Power(F.Plus(F.C1, F.Negate(n)), F.Plus(F.C1, F.Floor(F.Slot1))))), F.GreaterEqual(F.Slot1, F.C0))), F.C0)); // $$; return callFunction(function, k); } return F.NIL; }
@Override public IExpr cdf(IAST dist, IExpr k) { IExpr[] minMax = minmax(dist); if (minMax != null) { IExpr a = minMax[0]; IExpr b = minMax[1]; IExpr function = // [$ (Piecewise({{(1 - a + Floor(#))/(1 - a + b), a<=#<b}, {1, # >= b}}, 0)) & $] F.Function(F.Piecewise(F.List( F.List(F.Times(F.Power(F.Plus(F.C1, F.Negate(a), b), -1), F.Plus(F.C1, F.Negate(a), F.Floor(F.Slot1))), F.And(F.LessEqual(a, F.Slot1), F.Less(F.Slot1, b))), F.List(F.C1, F.GreaterEqual(F.Slot1, b))), F.C0)); // $$; return callFunction(function, k); } return F.NIL; }
IAST floorResult = Floor(Divide(Subtract(Pi, Im(logResult)), Times(C2, Pi))); IAST timesResult = Times(C2, I, Pi, floorResult); return Plus(logResult, timesResult);
public IExpr evaluate(final IAST ast) { if (ast.size() != 2) { throw new WrongNumberOfArguments(ast, 1, ast.size() - 1); } IExpr arg1 = ast.get(1); if (arg1.isSignedNumber()) { return ((ISignedNumber) arg1).floor(); } if (arg1.isSymbol()) { ISymbol sym = (ISymbol) arg1; return sym.mapConstantDouble(new FloorNumericFunction()); } if (arg1.isPlus()) { IAST[] result = ((IAST) arg1).split(new FloorPlusFunction()); if (result[0].size() > 1) { if (result[1].size() > 1) { result[0].add(F.Floor(result[1])); } return result[0]; } } return null; }
public IExpr evalCeiling(IExpr arg1) { if (arg1.isNumber()) { return ((INumber) arg1).ceilFraction(); } INumber number = arg1.evalNumber(); if (number != null) { return number.ceilFraction(); } if (arg1.isIntegerResult()) { return arg1; } if (arg1.isPlus()) { IASTAppendable[] splittedPlus = ((IAST) arg1).filter(new CeilingPlusFunction()); if (splittedPlus[0].size() > 1) { if (splittedPlus[1].size() > 1) { splittedPlus[0].append(F.Ceiling(splittedPlus[1].getOneIdentity(F.C0))); } return splittedPlus[0]; } } IExpr negExpr = AbstractFunctionEvaluator.getNormalizedNegativeExpression(arg1); if (negExpr.isPresent()) { return Negate(Floor(negExpr)); } return F.NIL; }
public IExpr evalFloor(IExpr arg1) { if (arg1.isNumber()) { return ((INumber) arg1).floorFraction(); } INumber number = arg1.evalNumber(); if (number != null) { return number.floorFraction(); } if (arg1.isIntegerResult()) { return arg1; } if (arg1.isPlus()) { IASTAppendable[] splittedPlus = ((IAST) arg1).filter(new FloorPlusFunction()); if (splittedPlus[0].size() > 1) { if (splittedPlus[1].size() > 1) { splittedPlus[0].append(F.Floor(splittedPlus[1].getOneIdentity(F.C0))); } return splittedPlus[0]; } } IExpr negExpr = AbstractFunctionEvaluator.getNormalizedNegativeExpression(arg1); if (negExpr.isPresent()) { return Negate(Ceiling(negExpr)); } return F.NIL; }
plusResult.appendArgs(timesAST.size(), i -> Negate(Divide(Arg(timesAST.get(i)), Times(C2, Pi)))); IAST expResult = Power(E, Times(C2, I, Pi, x2, Floor(plusResult))); if (!(timesResult instanceof IASTAppendable)) { timesResult = timesResult.copyAppendable();
-1)), F.List(j, F.C0, F.Floor(F.Times(F.C1D4, F.Plus(F.CN3, F.Times(F.C2, F.Abs(n)))))))), F.Times(F.CN1, F.Sin(F.Plus(F.Times(F.C1D2, F.Plus(F.CN1D2, n), F.Pi), F F.Power(F.Times(F.C2, z), F.Times(F.C2, j))), -1), F.Factorial(F.Plus(F.CN1D2, F.Times(F.C2, j), F.Abs(n)))), F.List(j, F.C0, F.Floor( F.Times(F.C1D4, F.Plus(F.CN1, F.Times(F.C2, F.Abs(n))))))))));
return Plus(Times(eps1, Plus(F.CN1, Times(C2, Floor(Times(C1D2, Plus(F.CN1, k)))))), Times(eps2, Plus(F.C1, Negate(F.UnitStep(Plus(F.CN3, k)))), Power(F.CN1, k)), Times(eps3, Plus(F.CN1, F.UnitStep(Plus(C2, Negate(k)))), Power(F.CN1, Plus(F.C1, k))),