public static IntegerSym valueOf(final int newnum) { return (newnum >= low && newnum <= high) ? cache[newnum + (-low)] : new IntegerSym(newnum); }
/** * Returns the nth-root of this integer. * * @return <code>k<code> such as <code>k^n <= this < (k + 1)^n</code> * @throws ArithmeticException * if this integer is negative and n is even. */ public IInteger nthRoot(int n) throws ArithmeticException { if (sign() == 0) { return IntegerSym.valueOf(0); } else if (sign() < 0) { if (n % 2 == 0) { // even exponent n throw new ArithmeticException(); } else { // odd exponent n return (IntegerSym) ((IntegerSym) negate()).nthRoot(n).negate(); } } else { IntegerSym result; IntegerSym temp = this; do { result = temp; temp = divideAndRemainder(temp.pow(n - 1))[0].add(temp.multiply(IntegerSym.valueOf(n - 1))).divideAndRemainder( IntegerSym.valueOf(n))[0]; } while (temp.compareTo(result) < 0); return result; } }
public IntegerSym jacobiSymbol(IntegerSym b) { if (this.compareTo(IntegerSym.valueOf(1)) == 0) { return IntegerSym.valueOf(1); } if (this.compareTo(IntegerSym.valueOf(2)) == 0) { return b.jacobiSymbolF(); } if (!isOdd()) { return this.quotient(IntegerSym.valueOf(2)).jacobiSymbol(b).multiply(IntegerSym.valueOf(2).jacobiSymbol(b)); } return b.quotient(this).jacobiSymbol(this).multiply(jacobiSymbolG(b)); }
@Override public IInteger shiftLeft(final int n) { if (n == 0) { return this; } if (n <= 31) { return valueOf(fIntValue << n); } return valueOf(toBigNumerator().shiftLeft(n)); }
IntegerSym phi = (IntegerSym) eulerPhi(); int size = phi.eulerPhi().toInt(); if (size <= 0) { return null; IAST ast = phi.factorInteger(); IntegerSym d[] = new IntegerSym[ast.size() - 1]; IAST element; element = (IAST) ast.get(i); IntegerSym q = (IntegerSym) element.get(1); d[i - 1] = phi.quotient(q); IntegerSym m = IntegerSym.valueOf(1); while (m.compareTo(n) < 0) { b = m.gcd(n).compareTo(IntegerSym.valueOf(1)) == 0; for (int i = 0; i < d.length; i++) { b = b && m.modPow(d[i], n).compareTo(IntegerSym.valueOf(1)) > 0; m = m.add(IntegerSym.valueOf(1));
final ArrayList<IInteger> result = new ArrayList<IInteger>(); IntegerSym b = this; if (sign() < 0) { b = b.multiply(IntegerSym.valueOf(-1)); result.add(IntegerSym.valueOf(-1)); result.add(IntegerSym.valueOf(0)); return result; result.add(IntegerSym.valueOf(1)); return result; IntegerSym is = valueOf(key); for (int i = 0; i < entry.getValue(); i++) { result.add(is); b = valueOf(rest); if (b.fInteger.isProbablePrime(32)) { result.add(b); IntegerSym p = IntegerSym.valueOf(1023); final IntegerSym q[] = b.divideAndRemainder(p); if (q[0].compareTo(p) < 0) { result.add(b); break; if (q[1].sign() == 0) { result.add(p);
if (sign() == 0) { result[0] = IntegerSym.valueOf(0); result[1] = IntegerSym.valueOf(1); return result; } else if (sign() < 0) { if (n % 2 == 0) { } else { result = ((IntegerSym) negate()).nthRootSplit(n); result[1] = (IInteger) result[1].negate(); return result; Map<Integer, Integer> map = new TreeMap<Integer, Integer>(); BigInteger rest = Primality.countPrimes1021(b.fInteger, map); result[0] = IntegerSym.valueOf(1); result[1] = IntegerSym.valueOf(rest); for (Map.Entry<Integer, Integer> entry : map.entrySet()) { IntegerSym is = valueOf(entry.getKey()); int val = entry.getValue(); int div = val / n; if (div > 0) { result[0] = result[0].multiply(is.pow(div)); result[1] = result[1].multiply(is.pow(mod));
/** * Create a large integer number. * * @param integerString * the integer number represented as a String * @param numberFormat * the format of the number (usually 10) * @return Object */ public static IInteger integer(final String integerString, final int numberFormat) { return IntegerSym.valueOf(integerString, numberFormat); }
return sqrt(); if (sign() == 0) { return F.C0; } else if (sign() < 0) { if (n % 2 == 0) { } else { return negate().nthRoot(n).negate(); do { result = temp; temp = divideAndRemainder(temp.pow(((long) n) - 1))[0] .add(temp.multiply(AbstractIntegerSym.valueOf(n - 1))) .divideAndRemainder(AbstractIntegerSym.valueOf(n))[0];
public IInteger eulerPhi() throws ArithmeticException { IAST ast = factorInteger(); IInteger phi = IntegerSym.valueOf(1); for (int i = 1; i < ast.size(); i++) { IAST element = (IAST) ast.get(i); IntegerSym q = (IntegerSym) element.get(1); int c = ((IInteger) element.get(2)).toInt(); if (c == 1) { phi = phi.multiply(q.subtract(IntegerSym.valueOf(1))); } else { phi = phi.multiply(q.subtract(IntegerSym.valueOf(1)).multiply(q.pow(c - 1))); } } return phi; }
@Override public IRational multiply(IRational parm1) { if (parm1.isZero()) { return F.C0; } if (parm1.isOne()) { return this; } if (parm1.isMinusOne()) { return this.negate(); } if (parm1 instanceof AbstractFractionSym) { return ((AbstractFractionSym) parm1).multiply(this); } if (parm1 instanceof IntegerSym) { IntegerSym is = (IntegerSym) parm1; long newnum = (long) fIntValue * (long) is.fIntValue; return valueOf(newnum); } BigIntegerSym p1 = (BigIntegerSym) parm1; BigInteger newnum = toBigNumerator().multiply(p1.toBigNumerator()); return valueOf(newnum); }
/** * @param value * @return */ @Override public IInteger multiply(int value) { switch (fIntValue) { case 0: return F.C0; case 1: return valueOf(value); case -1: return valueOf(value).negate(); default: if (value == 0) { return F.C0; } if (value == 1) { return this; } return valueOf((long) fIntValue * value); } }
public IntegerSym moebiusMu() { if (this.compareTo(IntegerSym.valueOf(1)) == 0) { return IntegerSym.valueOf(1); } IAST ast = factorInteger(); IntegerSym max = IntegerSym.valueOf(1); for (int i = 1; i < ast.size(); i++) { IAST element = (IAST) ast.get(i); IntegerSym c = (IntegerSym) element.get(2); if (c.compareTo(max) > 0) { max = c; } } if (max.compareTo(IntegerSym.valueOf(1)) > 0) { return IntegerSym.valueOf(0); } if (((ast.size() - 1) & 0x00000001) == 0x00000001) { // odd number return IntegerSym.valueOf(-1); } return IntegerSym.valueOf(1); }
public IAST factorInteger() { IInteger factor; IInteger last = IntegerSym.valueOf(-2); int count = 0; final List<IInteger> iFactors = factorize(); final IAST list = List(); IAST subList = null; for (int i = 0; i < iFactors.size(); i++) { factor = iFactors.get(i); if (!last.equals(factor)) { if (subList != null) { subList.add(IntegerSym.valueOf(count)); list.add(subList); } count = 0; subList = List(factor); } count++; last = factor; } if (subList != null) { subList.add(IntegerSym.valueOf(count)); list.add(subList); } return list; }
@Override public IInteger[] nthRootSplit(int n) throws ArithmeticException { IInteger[] result = new IInteger[2]; if (sign() == 0) { result[0] = F.C0; result[1] = F.C1; return result; } else if (sign() < 0) { if (n % 2 == 0) { // even exponent n throw new ArithmeticException(); } else { // odd exponent n result = negate().nthRootSplit(n); result[1] = result[1].negate(); return result; } } long b = fIntValue; long[] nthRoot = Primality.countRoot1021(b, n); result[0] = AbstractIntegerSym.valueOf(nthRoot[0]); result[1] = AbstractIntegerSym.valueOf(nthRoot[1]); return result; }
/** * Get the highest exponent of <code>base</code> that divides <code>this</code> * * @return the exponent */ @Override public IExpr exponent(IInteger base) { IInteger b = this; if (sign() < 0) { b = b.negate(); } else if (b.isZero()) { return F.CInfinity; } else if (b.isOne()) { return F.C0; } if (b.equals(base)) { return F.C1; } BigInteger rest = Primality.countExponent(b.toBigNumerator(), base.toBigNumerator()); return valueOf(rest); }
if (isOne() || isMinusOne()) { return F.List(F.C1); final IAST primeFactorsList = factorize(); int len = primeFactorsList.argSize();
/** {@inheritDoc} */ @Override public IExpr dec() { return add(F.CN1); }