@Override public IExpr mean(IAST dist) { if (dist.isAST2()) { // n/m return F.Divide(dist.arg1(), dist.arg2()); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); // arg1 * arg2^(-1) return F.Divide(ast.arg1(), ast.arg2()); }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { if (ast.size() == 2) { final long begin = System.currentTimeMillis(); final IExpr result = engine.evaluate(ast.arg1()); return List(Divide(F.num(System.currentTimeMillis() - begin), F.integer(1000L)), F.HoldForm(result)); } return F.NIL; }
@Override public IExpr variance(IAST dist) { if (dist.isAST2()) { // n/(m^2) return F.Divide(dist.arg1(), F.Sqr(dist.arg2())); } return F.NIL; }
/** * {@inheritDoc} */ @Override public IExpr getResult() { if (product.getN() > 0) { return F.eval(F.Exp(F.Divide(product.getResult(), F.integer(product.getN())))); // FastMath.exp(sumOfLogs.getResult() / sumOfLogs.getN()); } else { return null; } }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 2); if (ast.arg1().isList()) { IAST list = (IAST) ast.arg1(); return F.Divide(F.CentralMoment(list, F.C4), F.Power(F.CentralMoment(list, F.C2), F.C2)); } return F.NIL; }
@Override public IExpr variance(IAST dist) { if (dist.isAST2()) { IExpr n = dist.arg1(); IExpr m = dist.arg2(); // m - (m*Pochhammer(n, 1/2)^2)/n return F.Subtract(m, F.Divide(F.Times(m, F.Sqr(F.Pochhammer(n, F.C1D2))), n)); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 2); if (ast.arg1().isList()) { IAST list = (IAST) ast.arg1(); return F.Divide(F.CentralMoment(list, F.C3), F.Power(F.CentralMoment(list, F.C2), F.C3D2)); } return F.NIL; }
@Override public IExpr mean(IAST dist) { if (dist.isAST2()) { IExpr n = dist.arg1(); IExpr m = dist.arg2(); // (n,m) -> (Sqrt(m)*Pochhammer(n,1/2))/Sqrt(n) return F.Divide(F.Times(F.Sqrt(m), F.Pochhammer(n, F.C1D2)), F.Sqrt(n)); } return F.NIL; }
@Override public IExpr variance(IAST dist) { if (dist.isAST1()) { IExpr n = dist.arg1(); return F.Piecewise(F.List(F.List(F.Divide(n, F.Plus(F.CN2, n)), F.Greater(n, F.C2))), F.Indeterminate); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); IExpr a = ast.arg1(); IExpr b = ast.arg2(); int dim1 = a.isVector(); int dim2 = b.isVector(); if (dim1 >= 0 && dim1 == dim2) { return F.Divide(F.Covariance(a, b), F.Times(F.StandardDeviation(a), F.StandardDeviation(b))); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); if (ast.arg1().isList()) { IAST list = (IAST) ast.arg1(); IExpr r = ast.arg2(); return F.Divide(F.Total(F.Power(F.Subtract(list, F.Mean(list)), r)), F.Length(list)); } return F.NIL; }
@Override public IExpr mean(IAST dist) { if (dist.isAST3()) { int param[] = parameters(dist); if (param != null) { // N * (n / m_n) return F.ZZ(param[0]).multiply(F.QQ(param[1], param[2])); } IExpr N = dist.arg1(); IExpr n = dist.arg2(); IExpr m_n = dist.arg3(); return F.Divide(F.Times(N, n), m_n); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); IExpr arg1 = ast.arg1(); IExpr arg2 = ast.arg2(); int dim1 = arg1.isVector(); int dim2 = arg2.isVector(); if (dim1 > (-1) && dim2 > (-1)) { return ArcCos(Divide(Dot(arg1, arg2), Times(Norm(arg1), Norm(arg2)))); } return F.NIL; }
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; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkRange(ast, 2, 3); IExpr normFunction = F.Norm; if (ast.isAST2()) { normFunction = ast.arg2(); } IExpr arg1 = ast.arg1(); if (arg1.isAST(F.List, 1) && ast.isAST1()) { return arg1; } IExpr norm = engine.evaluate(F.unaryAST1(normFunction, ast.arg1())); if (norm.isZero()) { return arg1; } return F.Divide(ast.arg1(), norm); }
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; } }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 2); IExpr arg1 = ast.arg1(); int[] dim = arg1.isMatrix(); if (dim == null && arg1.isListOfLists()) { return F.NIL; } if (dim != null) { IAST matrix = (IAST) arg1; return F.Transpose(matrix.mapMatrixColumns(dim, v -> F.Standardize(v))); } IExpr sd = F.StandardDeviation.of(engine, arg1); if (!sd.isZero()) { return engine.evaluate(F.Divide(F.Subtract(arg1, F.Mean(arg1)), sd)); } return F.NIL; }
private static IExpr reduceFactorConstant(IExpr p, EvalEngine engine) { if (!engine.isNumericMode() && p.isPlus() && !engine.isTogetherMode()) { IExpr e = p; // ((reduceConstantTerm /@ (List @@ e)) // Transpose)[[1]] IExpr cTerms = F.Transpose .of(engine, F.Map(F.Function(F.unaryAST1(reduceConstantTerm, F.Slot1)), F.Apply(F.List, e))) .first(); // GCD @@ cTerms IExpr c = F.Apply.of(engine, F.GCD, cTerms); if (cTerms.last().isNegative()) { c = c.negate(); } return F.Times.of(engine, c, F.Distribute(F.Divide(e, c))); } return p; }
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))); }