/** * Generate the characteristic polynomial of a square matrix. * * @param dim * dimension of the square matrix * @param matrix * the square matrix * @param variable * the variable which should be used in the resulting characteristic polynomial * @return */ public static IAST generateCharacteristicPolynomial(int dim, IAST matrix, IExpr variable) { final IExpr[] valuesForIdentityMatrix = { F.C0, variable }; return F.Det(F.Subtract(matrix, diagonalMatrix(valuesForIdentityMatrix, dim))); }
@Override public IExpr variance(IAST dist) { if (dist.isAST1()) { IExpr N = dist.arg1(); return F.Times(N, F.Subtract(F.C1, N)); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkSize(ast, 3); // arg1 + (-1)*arg2 return F.Subtract(ast.arg1(), ast.arg2()); }
@Override public IExpr variance(IAST dist) { if (dist.isAST1()) { // (1-n) / n^2 IExpr n = dist.arg1(); return F.Times(F.Subtract(F.C1, n), F.Power(n, F.CN2)); } return F.NIL; }
@Override public IExpr variance(IAST dist) { if (dist.isAST2()) { // (1 - m) m n return F.Times(dist.arg1(), dist.arg2(), F.Subtract(F.C1, dist.arg2())); } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { if (ast.size() == 3) { return F.Subtract(F.Erf(ast.arg2()), F.Erf(ast.arg1())); } return super.evaluate(ast, engine); }
@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; }
private static IExpr rescale(IExpr x, IExpr min, IExpr max, EvalEngine engine) { IExpr sum = engine.evaluate(F.Subtract(max, min)); return engine.evaluate(F.Plus(F.Times(F.CN1, F.Power(sum, -1), min), F.Times(F.Power(sum, -1), x))); }
@Override public IExpr evaluate(final IAST ast) { Validate.checkSize(ast, 3); int[] dim = ast.get(1).isMatrix(); if (dim != null && dim[0] == dim[1]) { // a matrix with square dimensions final IExpr[] valuesForIdentityMatrix = { F.C0, ast.get(2) }; return F.eval(F.Det(F.Subtract(ast.get(1), IdentityMatrix .diagonalMatrix(valuesForIdentityMatrix, dim[0])))); } return null; } }
@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.isAST2()) { IExpr n = dist.arg1(); IExpr m = dist.arg2(); // Piecewise({{m*Gamma(1 - 1/n), 1 < n}}, Infinity) return F.Piecewise( F.List(F.List(F.Times(m, F.Gamma(F.Subtract(F.C1, F.Power(n, F.CN1)))), F.Less(F.C1, n))), F.CInfinity); } return F.NIL; }
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))); }
@Override public IExpr evaluate(final IAST ast) { Validate.checkSize(ast, 3); if (ast.get(1).isVector() >= 3) { if (ast.get(2).isVector() == 3) { IAST variables = (IAST) ast.get(2); IAST vector = (IAST) ast.get(1); IAST curlVector = F.List(); curlVector.add(F.Subtract(F.D(vector.get(3), variables.get(2)), F.D(vector.get(2), variables.get(3)))); curlVector.add(F.Subtract(F.D(vector.get(1), variables.get(3)), F.D(vector.get(3), variables.get(1)))); curlVector.add(F.Subtract(F.D(vector.get(2), variables.get(1)), F.D(vector.get(1), variables.get(2)))); for (int i = 4; i < vector.size(); i++) { curlVector.add(vector.get(i)); } return curlVector; } } return null; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { Validate.checkRange(ast, 2, 4); if (ast.arg1().isAST()) { if (ast.size() == 3 && ast.arg2().isNumber()) { IAST listArg1 = (IAST) ast.arg1(); if (listArg1.size() > 1) { INumber arg2 = (INumber) ast.arg2(); // Norm() is the default distance function for numeric // data IExpr distanceFunction = F.Function(F.Norm(F.Subtract(F.Slot1, F.Slot2))); return numericalNearest(listArg1, arg2, distanceFunction, engine); } } } return F.NIL; }
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; }
@Override public IExpr evaluate(final IAST functionList, EvalEngine engine) { if (functionList.size() != 3) { throw new WrongNumberOfArguments(functionList, 2, functionList.argSize()); } IExpr arg1 = functionList.arg1(); IExpr arg2 = functionList.arg2(); int dim1 = arg1.isVector(); if (dim1 > (-1)) { int dim2 = arg2.isVector(); if (dim1 == dim2) { if (dim1 == 0) { return F.C0; } return F.Subtract(F.C1, F.Divide(F.Dot(arg1, arg2), F.Times(F.Norm(arg1), F.Norm(arg2)))); } } return F.NIL; }
@Override public IExpr evaluate(final IAST functionList, EvalEngine engine) { if (functionList.size() != 3) { throw new WrongNumberOfArguments(functionList, 2, functionList.argSize()); } IExpr arg1 = functionList.arg1(); IExpr arg2 = functionList.arg2(); int dim1 = arg1.isVector(); if (dim1 > (-1)) { int dim2 = arg2.isVector(); if (dim1 == dim2) { if (dim1 == 0) { return F.C0; } return F.Total(F.Divide(F.Abs(F.Subtract(arg1, arg2)), F.Plus(F.Abs(arg1), F.Abs(arg2)))); } } return F.NIL; }
@Override public IExpr evaluate(final IAST ast, EvalEngine engine) { if (ast.size() != 3) { throw new WrongNumberOfArguments(ast, 2, ast.argSize()); } IExpr u = ast.arg1(); IExpr v = ast.arg2(); int dim1 = u.isVector(); if (dim1 > (-1)) { int dim2 = v.isVector(); if (dim1 == dim2) { if (dim1 == 0) { return F.C0; } return F.Total(F.Divide(F.Abs(F.Subtract(u, v)), F.Total(F.Abs(F.Plus(u, v))))); } } return F.NIL; }
private IExpr resultant(IExpr a, IExpr b, ISymbol x, EvalEngine engine) { IExpr aExp = F.Exponent.of(engine, a, x); IExpr bExp = F.Exponent.of(engine, b, x); if (b.isFree(x)) { return F.Power(b, aExp); } IExpr abExp = aExp.times(bExp); if (F.Less.ofQ(engine, aExp, bExp)) { return F.Times(F.Power(F.CN1, abExp), resultant(b, a, x, engine)); } IExpr r = F.PolynomialRemainder.of(engine, a, b, x); IExpr rExp = r; if (!r.isZero()) { rExp = F.Exponent.of(engine, r, x); } return F.Times(F.Power(F.CN1, abExp), F.Power(F.Coefficient(b, x, bExp), F.Subtract(aExp, rExp)), resultant(b, r, x, engine)); }