public static void viewAd(String id) {
Ad ad = Ad.findById(Long.parseLong(id));
List<Category> cats = Category.find("categorytype_id=?1 order by id", "1").fetch();
EntityManager entityManager = play.db.jpa.JPA.em();
List<BigInteger> bCounts =
entityManager
.createNativeQuery(
"select count(*) as maxCount from Ad as a group by category_id order by maxCount")
.getResultList();
int min = bCounts.get(0).intValue();
int max = bCounts.get(bCounts.size() - 1).intValue();
bCounts =
entityManager
.createNativeQuery(
"select count(*) as maxCount from Ad as a group by category_id order by category_id ")
.getResultList();
List<String> fonts = new ArrayList<String>();
for (int i = 0; i < bCounts.size(); i++) {
BigInteger count = bCounts.get(i);
int x = Ads.getFontSize(count.intValue(), min, max);
fonts.add(String.valueOf(x));
}
render(ad, fonts, min, max, cats);
}
/**
* Returns the square root of {@code x}, rounded with the specified rounding mode.
*
* @throws IllegalArgumentException if {@code x < 0}
* @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code
* sqrt(x)} is not an integer
*/
@GwtIncompatible // TODO
@SuppressWarnings("fallthrough")
public static BigInteger sqrt(BigInteger x, RoundingMode mode) {
checkNonNegative("x", x);
if (fitsInLong(x)) {
return BigInteger.valueOf(LongMath.sqrt(x.longValue(), mode));
}
BigInteger sqrtFloor = sqrtFloor(x);
switch (mode) {
case UNNECESSARY:
checkRoundingUnnecessary(sqrtFloor.pow(2).equals(x)); // fall through
case FLOOR:
case DOWN:
return sqrtFloor;
case CEILING:
case UP:
int sqrtFloorInt = sqrtFloor.intValue();
boolean sqrtFloorIsExact =
(sqrtFloorInt * sqrtFloorInt == x.intValue()) // fast check mod 2^32
&& sqrtFloor.pow(2).equals(x); // slow exact check
return sqrtFloorIsExact ? sqrtFloor : sqrtFloor.add(BigInteger.ONE);
case HALF_DOWN:
case HALF_UP:
case HALF_EVEN:
BigInteger halfSquare = sqrtFloor.pow(2).add(sqrtFloor);
/*
* We wish to test whether or not x <= (sqrtFloor + 0.5)^2 = halfSquare + 0.25. Since both x
* and halfSquare are integers, this is equivalent to testing whether or not x <=
* halfSquare.
*/
return (halfSquare.compareTo(x) >= 0) ? sqrtFloor : sqrtFloor.add(BigInteger.ONE);
default:
throw new AssertionError();
}
}
/**
* Given 10 features (and metacards) exist that match search criteria, since page size=4 and
* startIndex=0, should get 4 results back - metacards 1 thru 4.
*
* @throws WfsException
* @throws TransformerConfigurationException
* @throws UnsupportedQueryException
*/
@Test
public void testPagingStartIndexZero()
throws WfsException, TransformerConfigurationException, UnsupportedQueryException {
// Setup
int pageSize = 4;
int startIndex = 0;
WfsSource source =
getWfsSource(
ONE_TEXT_PROPERTY_SCHEMA,
MockWfsServer.getFilterCapabilities(),
Wfs20Constants.EPSG_4326_URN,
10,
false);
Filter filter = builder.attribute(Metacard.ANY_TEXT).is().like().text(LITERAL);
Query query = new QueryImpl(filter, startIndex, pageSize, null, false, 0);
// Execute
GetFeatureType featureType = source.buildGetFeatureRequest(query);
BigInteger startIndexGetFeature = featureType.getStartIndex();
BigInteger countGetFeature = featureType.getCount();
// Verify
assertThat(countGetFeature.intValue(), is(pageSize));
assertThat(startIndexGetFeature.intValue(), is(startIndex));
}
public int getNumberPosition() {
boolean updated = false;
BigInteger left = ((Ind) this.getObject()).getLeft();
int leftInt = 0;
if (left != null) {
leftInt = left.intValue();
}
BigInteger firstLine = ((Ind) this.getObject()).getFirstLine();
BigInteger hanging = ((Ind) this.getObject()).getHanging();
// SPEC: The firstLine and hanging attributes are mutually exclusive, if both are specified,
// then
// the firstLine value is ignored.
if (hanging != null) {
// <w:ind w:left="360" w:hanging="360"/>
int hangingInt = hanging.intValue();
return (leftInt - hangingInt);
} else {
int firstLineInt = 0;
if (firstLine != null) {
firstLineInt = firstLine.intValue();
}
return (leftInt + firstLineInt);
}
}
@Override
public void setXslFO(Element foElement) {
// <w:ind w:left="360" w:hanging="360"/>
boolean updated = false;
BigInteger left = ((Ind) this.getObject()).getLeft();
if (left != null) {
foElement.setAttribute(FO_NAME, UnitsOfMeasurement.twipToBest(left.intValue()));
updated = true;
}
BigInteger firstLine = ((Ind) this.getObject()).getFirstLine();
BigInteger hanging = ((Ind) this.getObject()).getHanging();
// SPEC: The firstLine and hanging attributes are mutually exclusive, if both are specified,
// then
// the firstLine value is ignored.
if (hanging != null) {
foElement.setAttribute(
FO_NAME_TEXT_INDENT, UnitsOfMeasurement.twipToBest(-hanging.intValue()));
} else if (firstLine != null) {
foElement.setAttribute(
FO_NAME_TEXT_INDENT, UnitsOfMeasurement.twipToBest(firstLine.intValue()));
updated = true;
}
if (!updated) {
log.warn("Only left/first-line indentation is handled at present");
}
}
@Override
public String getCssProperty() {
// Note regarding numbering case; handling of tab after the number:-
// We get this right in the PDF case, via setXslFOListBlock below.
// We don't attempt to get the tab right in the HTML case,
// since without some research, I don't know what markup would be required.
String prop = "position: relative; ";
BigInteger left = ((Ind) this.getObject()).getLeft();
if (left != null) {
prop = prop + composeCss(CSS_NAME, UnitsOfMeasurement.twipToBest(left.intValue()));
}
// SPEC: The firstLine and hanging attributes are mutually exclusive, if both are specified,
// then
// the firstLine value is ignored.
BigInteger firstline = ((Ind) this.getObject()).getFirstLine();
BigInteger hanging = ((Ind) this.getObject()).getHanging();
if (hanging != null) {
prop =
prop + composeCss("text-indent", "-" + UnitsOfMeasurement.twipToBest(hanging.intValue()));
} else if (firstline != null) {
prop = prop + composeCss("text-indent", UnitsOfMeasurement.twipToBest(firstline.intValue()));
}
if (left == null && firstline == null && hanging == null) {
log.debug("What to do with " + XmlUtils.marshaltoString(this.getObject(), true, true));
prop = CSS_NULL;
}
return prop;
}
public static void main(String[] args) {
Map<Integer, CalcularPolignos> poligono = new HashMap<>();
Scanner sc = new Scanner(System.in);
System.out.println("Digite o número de lados do poligono: ");
BigInteger lados = sc.nextBigInteger();
int opcao = 0;
if (lados.intValue() < 3) {
System.out.println("Valor negativo para número de lados do poligno, tente novamente!");
main(args);
} else if (lados.intValue() == 3) {
opcao = 1;
} else if (lados.intValue() == 4) {
opcao = 2;
} else if (lados.intValue() > 4) {
opcao = 3;
}
System.out.println("Digite o Tamanho do Lado do Poligono: ");
BigDecimal tamanho = sc.nextBigDecimal();
poligono.put(1, new Triagulo(lados, tamanho));
poligono.put(2, new Quadrilatero(lados, tamanho));
poligono.put(3, new OutrosPoligonos(lados, tamanho));
Controller cont = new Controller();
cont.calcular(lados, poligono.get(opcao));
}
/**
* Converts, if possible, a key specification into a {@link BCMcElieceCCA2PrivateKey}. Currently,
* the following key specifications are supported: {@link McElieceCCA2PrivateKeySpec}, {@link
* PKCS8EncodedKeySpec}.
*
* @param keySpec the key specification
* @return the McEliece CCA2 private key
* @throws InvalidKeySpecException if the KeySpec is not supported.
*/
public PrivateKey generatePrivate(KeySpec keySpec) throws InvalidKeySpecException {
if (keySpec instanceof McElieceCCA2PrivateKeySpec) {
return new BCMcElieceCCA2PrivateKey((McElieceCCA2PrivateKeySpec) keySpec);
} else if (keySpec instanceof PKCS8EncodedKeySpec) {
// get the DER-encoded Key according to PKCS#8 from the spec
byte[] encKey = ((PKCS8EncodedKeySpec) keySpec).getEncoded();
// decode the PKCS#8 data structure to the pki object
PrivateKeyInfo pki;
try {
pki = PrivateKeyInfo.getInstance(ASN1Primitive.fromByteArray(encKey));
} catch (IOException e) {
throw new InvalidKeySpecException("Unable to decode PKCS8EncodedKeySpec: " + e);
}
try {
// get the inner type inside the BIT STRING
ASN1Primitive innerType = pki.parsePrivateKey().toASN1Primitive();
// build and return the actual key
ASN1Sequence privKey = (ASN1Sequence) innerType;
// decode oidString (but we don't need it right now)
String oidString = ((ASN1ObjectIdentifier) privKey.getObjectAt(0)).toString();
// decode <n>
BigInteger bigN = ((ASN1Integer) privKey.getObjectAt(1)).getValue();
int n = bigN.intValue();
// decode <k>
BigInteger bigK = ((ASN1Integer) privKey.getObjectAt(2)).getValue();
int k = bigK.intValue();
// decode <fieldPoly>
byte[] encFieldPoly = ((ASN1OctetString) privKey.getObjectAt(3)).getOctets();
// decode <goppaPoly>
byte[] encGoppaPoly = ((ASN1OctetString) privKey.getObjectAt(4)).getOctets();
// decode <p>
byte[] encP = ((ASN1OctetString) privKey.getObjectAt(5)).getOctets();
// decode <h>
byte[] encH = ((ASN1OctetString) privKey.getObjectAt(6)).getOctets();
// decode <qInv>
ASN1Sequence qSeq = (ASN1Sequence) privKey.getObjectAt(7);
byte[][] encQInv = new byte[qSeq.size()][];
for (int i = 0; i < qSeq.size(); i++) {
encQInv[i] = ((ASN1OctetString) qSeq.getObjectAt(i)).getOctets();
}
return new BCMcElieceCCA2PrivateKey(
new McElieceCCA2PrivateKeySpec(
OID, n, k, encFieldPoly, encGoppaPoly, encP, encH, encQInv));
} catch (IOException cce) {
throw new InvalidKeySpecException("Unable to decode PKCS8EncodedKeySpec.");
}
}
throw new InvalidKeySpecException("Unsupported key specification: " + keySpec.getClass() + ".");
}
/** @tests java.math.BigInteger#intValue() */
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "intValue",
args = {})
public void test_intValue() {
assertTrue("Incorrect intValue for 2**70", twoToTheSeventy.intValue() == 0);
assertTrue("Incorrect intValue for 2", two.intValue() == 2);
}
/** wrapper method for UnsignedIntegers that use BigIntegers to store value */
private final String getName(final BigInteger value) {
logger.warn(
"AntennaEventType must convert BigInteger "
+ value
+ " to Integer value "
+ value.intValue());
return getName(value.intValue());
}
/** wrapper method for UnsignedIntegers that use BigIntegers to store value */
private final boolean isValidValue(final BigInteger value) {
logger.warn(
"AntennaEventType must convert BigInteger "
+ value
+ " to Integer value "
+ value.intValue());
return isValidValue(value.intValue());
}
/** wrapper method for UnsignedIntegers that use BigIntegers to store value */
private final boolean isValidValue(final BigInteger value) {
logger.warn(
"AirProtocolsArray must convert BigInteger "
+ value
+ " to Integer value "
+ value.intValue());
return isValidValue(value.intValue());
}
/** wrapper method for UnsignedIntegers that use BigIntegers to store value */
private final String getName(final BigInteger value) {
logger.warn(
"AirProtocolsArray must convert BigInteger "
+ value
+ " to Integer value "
+ value.intValue());
return getName(value.intValue());
}
/**
* Title: deleteMenuItem
*
* <p>Description:
*
* @param menuItemId
* @param MenuGroupId
* @return
* @throws Exception
* @see com.topit.frame.busniess.base.ISysMenuService#deleteMenuItem(java.math.BigInteger,
* java.math.BigInteger)
*/
public boolean deleteMenuItem(BigInteger menuItemId) throws Exception {
boolean flag = false;
SysMenuItem source = menuOptionDao.findById(menuItemId.intValue());
// 跟新源节点周围的链接状态
menuOptionDao.UpdateSourceNodes(source);
menuOptionDao.delete(menuItemId.intValue());
flag = true;
return flag;
}
// Determines if a specified integer is prime using the Miller-Rabin
// primality test.
//
// Performance: O(k log^3(n))
//
// Args:
// n (BigInteger): The number to perform the primality test.
// k (int): The number of iterations to perform.
//
// Returns:
// (bool): Denotes the results of the primality test.
public boolean is_prime(BigInteger n, int k) {
if (n.compareTo(TWO) < 0) return false;
else if (n.compareTo(TWO) == 0) return true;
else if (n.mod(TWO).compareTo(ZERO) == 0) return false;
BigInteger i = ZERO;
// Express n - 1 = 2^i * d, where d is odd by
// factoring powers of 2 from n - 1.
while (true) {
BigInteger modulus = TWO.pow(i.intValue());
BigInteger m = n.subtract(ONE).mod(modulus);
if (m.compareTo(ZERO) == 0) i = i.add(ONE);
else if (m.compareTo(ZERO) > 0) break;
}
i = i.subtract(ONE);
BigInteger divisor = TWO.pow(i.intValue());
BigInteger d = n.subtract(ONE).divide(divisor);
// The more k iterations, the more accurate the result. It decreases
// the likelihood of a composite number passing the Miller-Rabin test.
for (int j = 0; j < k; ++j) {
// Pick a random integer a in the range [2, n - 1].
BigInteger a = random(TWO, n.subtract(ONE));
// Let x = a^d mod n.
BigInteger x = a.modPow(d, n);
// Either n is prime or a is a strong liar for n. Try another
// random a to determine if a is truly prime.
if (x.compareTo(ONE) == 0 || x.compareTo(n.subtract(ONE)) == 0) continue;
boolean flag = false;
// Repeat i - 1 times to determine if n is prime.
for (BigInteger p = ZERO; p.compareTo(i.subtract(ONE)) < 0; p = p.add(ONE)) {
// Let x = x^2 mod n.
x = x.modPow(TWO, n);
// Retry with another random a.
if (x.compareTo(n.subtract(ONE)) == 0) {
flag = true;
break;
}
}
// Most likely n is composite.
if (!flag) return false;
}
return true;
}
/**
* Signals the start of a new message to process with this <code>UST</code> with a designated
* <emIndex</em> value.
*
* @param ndx the <em>Index</em> to use with the new message.
* @throws LimitReachedException if the value of the <em>Index</em> has reached its allowed upper
* bound. To use this <code>UST</code> instance a new initialisation (with a new user-supplied
* key material) should occur.
* @throws InvalidKeyException if the underlying cipher, used in either or both the Integrity
* Protection and Confidentiality Protection functions has detected an exception.
*/
public void beginMessageWithIndex(BigInteger ndx)
throws LimitReachedException, InvalidKeyException {
if (ndx.compareTo(maxIndex) > 0) {
throw new LimitReachedException();
}
index = ndx;
// depending on the desired services, get keying material from the
// internal keystream generator and complete the relevant attributes.
// the key size shall be the same size as the user-supplied key material.
// remember we need the 1st generator if integrity is required even when
// confidentiality is not
if (wantConfidentiality || wantIntegrity) {
byte[] cpKey = new byte[keysize];
keystream.nextBytes(cpKey, 0, keysize);
cpAttributes.put(IBlockCipher.KEY_MATERIAL, cpKey);
if (cpStream instanceof ICMGenerator) {
cpAttributes.put(ICMGenerator.SEGMENT_INDEX, index);
} else {
cpAttributes.put(UMacGenerator.INDEX, new Integer(index.intValue()));
}
cpStream.init(cpAttributes);
}
if (wantIntegrity) {
byte[] ipKey = new byte[keysize];
keystream.nextBytes(ipKey, 0, keysize);
ipAttributes.put(IBlockCipher.KEY_MATERIAL, ipKey);
if (ipStream instanceof ICMGenerator) {
ipAttributes.put(ICMGenerator.SEGMENT_INDEX, index);
} else {
ipAttributes.put(UMacGenerator.INDEX, new Integer(index.intValue()));
}
ipStream.init(ipAttributes);
// get prefix bytes
byte[] prefix = new byte[macLength];
cpStream.nextBytes(prefix, 0, macLength);
macAttributes.put(TMMH16.PREFIX, prefix);
mac = new TMMH16();
macAttributes.put(TMMH16.KEYSTREAM, ipStream);
mac.init(macAttributes);
}
ready = true;
}
private static void checkNormaliseBaseTenResult(ExpandedDouble orig, NormalisedDecimal result) {
String sigDigs = result.getSignificantDecimalDigits();
BigInteger frac = orig.getSignificand();
while (frac.bitLength() + orig.getBinaryExponent() < 200) {
frac = frac.multiply(BIG_POW_10);
}
int binaryExp = orig.getBinaryExponent() - orig.getSignificand().bitLength();
String origDigs = frac.shiftLeft(binaryExp + 1).toString(10);
if (!origDigs.startsWith(sigDigs)) {
throw new AssertionFailedError("Expected '" + origDigs + "' but got '" + sigDigs + "'.");
}
double dO = Double.parseDouble("0." + origDigs.substring(sigDigs.length()));
double d1 = Double.parseDouble(result.getFractionalPart().toPlainString());
BigInteger subDigsO = BigInteger.valueOf((int) (dO * 32768 + 0.5));
BigInteger subDigsB = BigInteger.valueOf((int) (d1 * 32768 + 0.5));
if (subDigsO.equals(subDigsB)) {
return;
}
BigInteger diff = subDigsB.subtract(subDigsO).abs();
if (diff.intValue() > 100) {
// 100/32768 ~= 0.003
throw new AssertionFailedError("minor mistake");
}
}
/** See CMIS 1.0 section 2.2.2.4 getTypeDescendants */
public List<TypeDefinitionContainer> getTypesDescendants(
String typeId, BigInteger depth, Boolean includePropertyDefinitions) {
List<TypeDefinitionContainer> result = new ArrayList<TypeDefinitionContainer>();
// check depth
int d = depth == null ? -1 : depth.intValue();
if (d == 0) {
throw new CmisInvalidArgumentException("Depth must not be 0!");
}
// set property definition flag to default value if not set
boolean ipd = Boolean.TRUE.equals(includePropertyDefinitions);
if (typeId == null) {
result.add(getTypesDescendants(d, fTypes.get(FOLDER_TYPE_ID), ipd));
result.add(getTypesDescendants(d, fTypes.get(DOCUMENT_TYPE_ID), ipd));
} else {
TypeDefinitionContainer tc = fTypes.get(typeId);
if (tc != null) {
result.add(getTypesDescendants(d, tc, ipd));
}
}
return result;
}
@AuditTrail
public Invoice loadLast(BigInteger accountId) {
return this.jdbcTemplate.queryForObject(
"select * from invoice where account_id = ? and period_to = (select max(period_to) from invoice) limit 1",
new Object[] {accountId.intValue()},
new InvoiceRowMapper());
}
protected void convertVertexLayout(
final LayoutVertexFactsType vertex, final GraphicsType graphics) throws CanoniserException {
if (vertex != null) {
final FillType fill = ANF_FACTORY.createFillType();
// Convert all Attributes
final LayoutAttributesFactsType attr = vertex.getAttributes();
for (final JAXBElement<?> element : attr.getAutosizeOrBackgroundColorOrBendable()) {
final Object elementValue = element.getValue();
if (elementValue instanceof LayoutRectangleType) {
try {
convertLayoutRectangleAttribute((LayoutRectangleType) elementValue, graphics);
} catch (final ParseException e) {
throw new CanoniserException(
"Could not convert layout of element " + vertex.getId(), e);
}
}
if (element.getName().getLocalPart().equals(BACKGROUND_COLOR)
&& element.getValue() != null) {
final BigInteger color = (BigInteger) element.getValue();
fill.setColor(ConversionUtils.convertColorToString(color.intValue()));
}
}
fill.setImage(vertex.getIconpath());
graphics.setFill(fill);
}
}
public static synchronized int generateMD5Id(Object... object) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos;
oos = new ObjectOutputStream(baos);
for (Object x : object) {
if (x == null) oos.writeChars("null");
else if (x instanceof Integer) oos.writeInt((Integer) x);
else if (x instanceof String) oos.writeChars((String) x);
else if (x instanceof Double) oos.writeDouble((Double) x);
else if (x instanceof Class) oos.writeChars(((Class<?>) x).getName());
}
oos.close();
MessageDigest m = MessageDigest.getInstance("MD5");
m.update(baos.toByteArray());
BigInteger testObjectHash = new BigInteger(m.digest());
return testObjectHash.intValue();
} catch (IOException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return 0;
}
/**
* Convert decimal to hexadecimal�iNo limit string length�j <br>
* Return hexadecimal string (unsigned integer number string) from decimal(integer number) <br>
* In case parameter is a minus number, return blank string <br>
*
* @param argStr decimal string
* @return hexadecimal string
*/
public static String chgHexString(String argStr) {
// In case parameter is a minus number, return blank string
if (argStr.charAt(0) == '-') {
return "";
}
StringBuffer hexb = new StringBuffer();
BigInteger bi = new BigInteger(argStr);
int tempInt;
BigInteger tempBi;
// Convert each 4 bit, start from the end.
for (int bitlength = bi.bitLength(); bitlength > 0; bitlength -= 4) {
tempBi = bi.and(HEX_MASK);
tempInt = tempBi.intValue();
hexb.append(HEX_STR.charAt(tempInt));
bi = bi.shiftRight(4);
}
// correction after converting
int hexlength = hexb.length();
if (hexlength == 0) {
// In case value =0, put "00"
hexb.append("00");
} else if ((hexlength % 2) == 1) {
// After converting, if result is a old number string, add "0" at
// the end of string
hexb.append("0");
}
// Reverse result string (because string was converted from the
// 4-bit-end)
return hexb.reverse().toString();
}
public static String set(final String lhs, BigInteger index, char value) {
int idx = index.intValue();
// hmmm, not exactly efficient!
StringBuilder sb = new StringBuilder(lhs);
sb.setCharAt(idx, value);
return sb.toString();
}
public static void main(String argv[]) {
// do some simple operations
System.out.println("SimpleITK says 'Hello World' from Java");
if (argv.length < 2) {
System.out.println("Usage: java ImageConnection <input> <output>");
return;
}
ImageFileReader reader = new ImageFileReader();
reader.setFileName(argv[0]);
Image img = reader.execute();
PixelContainer pixelsContainer = img.getPixelContainer();
java.math.BigInteger t = pixelsContainer.getNumberOfPixels();
int numberOfPixels = t.intValue();
int[] buffer = new int[numberOfPixels];
buffer[0] = 13;
buffer[1] = 2;
buffer[2] = 19;
pixelsContainer.setBufferAsUnsignedInt8(buffer, numberOfPixels);
}
@Test(timeout = 5000L)
public void powExactIntIntExact() {
for (int base : INTS) {
for (int power : INTS) {
if (power < 0) continue;
boolean overflow =
BigInteger.valueOf(31 - Integer.numberOfLeadingZeros(Math.abs(base)))
.multiply(BigInteger.valueOf(power))
.compareTo(BigInteger.valueOf(32))
> 0;
BigInteger expected = overflow ? null : BigInteger.valueOf(base).pow(power);
if (expected != null && expected.bitLength() <= 31) {
int value = powExact(base, power);
assertEquals(base + " ^ " + power, expected.intValue(), value);
assertEquals(base + " ^ " + power, (int) Math.pow(base, power), value);
assertEquals(base + " ^ " + power, pow(base, power), value);
} else {
try {
powExact(base, power);
fail("Should overflow: " + base + " ^ " + power);
} catch (ArithmeticException e) {
}
}
}
}
}
/**
* Finds factorial value of given number.
*
* @param n number of which factorial to find
* @return factorial value
*/
public static BigInteger factorial(BigInteger n) {
BigInteger result = BigInteger.ONE;
for (int i = 1; i <= n.intValue(); i++) {
result = result.multiply(new BigInteger(i + ""));
}
return result;
}
public void init(BigInteger prime, BigInteger N, BigInteger root) {
int target = N.mod(prime).intValue();
this.prime = prime.intValue();
log = Math.log(this.prime);
long[] flats = MathUtils.ressol(this.prime, target);
int solutions = 0;
for (int i = 0; i < flats.length; i++) {
if (flats[i] > -1) {
solutions++;
}
}
positions = new long[solutions];
for (int i = 0; i < flats.length; i++) {
if (flats[i] <= -1) {
continue;
}
positions[i] = flats[i] - root.mod(prime).intValue();
if (positions[i] < 0) {
positions[i] += this.prime;
}
}
if (positions.length == 2 && positions[0] > positions[1]) {
long tmp = positions[0];
positions[0] = positions[1];
positions[1] = tmp;
}
}
@Override
public int hashCode() {
byte[] bytes = name.toString().getBytes();
BigInteger bigInt = new BigInteger(bytes);
int val = bigInt.bitCount() + bigInt.intValue();
return val + idx;
}
protected void convertNumberToInt() throws IOException, JsonParseException {
// First, converting from long ought to be easy
if ((_numTypesValid & NR_LONG) != 0) {
// Let's verify it's lossless conversion by simple roundtrip
int result = (int) _numberLong;
if (((long) result) != _numberLong) {
_reportError("Numeric value (" + getText() + ") out of range of int");
}
_numberInt = result;
} else if ((_numTypesValid & NR_BIGINT) != 0) {
// !!! Should check for range...
_numberInt = _numberBigInt.intValue();
} else if ((_numTypesValid & NR_DOUBLE) != 0) {
// Need to check boundaries
if (_numberDouble < MIN_INT_D || _numberDouble > MAX_INT_D) {
reportOverflowInt();
}
_numberInt = (int) _numberDouble;
} else if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
if (BD_MIN_INT.compareTo(_numberBigDecimal) > 0
|| BD_MAX_INT.compareTo(_numberBigDecimal) < 0) {
reportOverflowInt();
}
_numberInt = _numberBigDecimal.intValue();
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_INT;
}
public int Decrypto(BigInteger c) {
BigInteger nSquare = n.multiply(n);
BigInteger Ans = c.modPow(lambda, nSquare);
Ans = Ans.subtract(BigInteger.ONE).divide(n);
Ans = Ans.remainder(n).multiply(nu).remainder(n);
return Ans.intValue();
}