Exemple #1
0
 public static void main(String args[]) throws Exception {
   Scanner cin = new Scanner(System.in);
   BigInteger s, M;
   int p, i;
   while (cin.hasNext()) {
     p = cin.nextInt();
     s = BigInteger.valueOf(4);
     M = BigInteger.ONE;
     M = M.shiftLeft(p).subtract(BigInteger.ONE);
     for (i = 0; i < p - 2; ++i) {
       s = s.multiply(s).subtract(BigInteger.valueOf(2));
       while (s.bitLength() > p) {
         s = s.shiftRight(p).add(s.and(M));
       }
     }
     if (s.compareTo(BigInteger.ZERO) == 0 || s.compareTo(M) == 0) {
       System.out.println(0);
       continue;
     }
     String ans = "";
     while (s.compareTo(BigInteger.ZERO) > 0) {
       long buf = s.mod(BigInteger.valueOf(16)).longValue();
       ans += Integer.toHexString((int) buf);
       s = s.divide(BigInteger.valueOf(16));
     }
     for (i = ans.length() - 1; i >= 0; --i) System.out.print(ans.charAt(i));
     System.out.println();
   }
 }
  /**
   * Sets the start quantity of the activity based on the data of the shape.
   *
   * @param activity
   * @param shape The resource shape
   */
  private void setStartAndCompletionQuantity(Activity activity, GenericShape shape) {

    /* Start quantity */

    String startQuantity = shape.getProperty("startquantity");
    if (startQuantity != null) {
      try {
        activity.setStartQuantity(BigInteger.valueOf(Integer.valueOf(startQuantity)));
      } catch (Exception e) {
        e.printStackTrace();
        /* Set to default value in case of an exception */
        activity.setStartQuantity(BigInteger.valueOf(1));
      }
    }

    /* Completion quantity */
    String completionQuantity = shape.getProperty("completionquantity");
    if (completionQuantity != null) {
      try {
        activity.setCompletionQuantity(BigInteger.valueOf(Integer.valueOf(completionQuantity)));
      } catch (Exception e) {
        /* Set to default value in case of an exception */
        e.printStackTrace();
        activity.setCompletionQuantity(BigInteger.valueOf(1));
      }
    }
  }
  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");
    }
  }
  /** Get the data type considering a known max value */
  protected final DataTypeDefinition getDataTypeForMAX_VAL(
      SchemaDefinition schema, BigInteger value) {
    DataTypeDefinition type;

    if (BigInteger.valueOf(Byte.MAX_VALUE).compareTo(value) >= 0) {
      type =
          new DefaultDataTypeDefinition(
              this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 2, 0, false, false);
    } else if (BigInteger.valueOf(Short.MAX_VALUE).compareTo(value) >= 0) {
      type =
          new DefaultDataTypeDefinition(
              this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 4, 0, false, false);
    } else if (BigInteger.valueOf(Integer.MAX_VALUE).compareTo(value) >= 0) {
      type =
          new DefaultDataTypeDefinition(
              this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 9, 0, false, false);
    } else if (BigInteger.valueOf(Long.MAX_VALUE).compareTo(value) >= 0) {
      type =
          new DefaultDataTypeDefinition(
              this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 18, 0, false, false);
    } else {
      type =
          new DefaultDataTypeDefinition(
              this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 38, 0, false, false);
    }

    return type;
  }
Exemple #5
0
  /**
   * Constructs a BigFraction from a floating-point number.
   *
   * <p>Warning: round-off error in IEEE floating point numbers can result in answers that are
   * unexpected. For example, System.out.println(new BigFraction(1.1)) will print:
   * 2476979795053773/2251799813685248
   *
   * <p>This is because 1.1 cannot be expressed exactly in binary form. The given fraction is
   * exactly equal to the internal representation of the double-precision floating-point number.
   * (Which, for 1.1, is: (-1)^0 * 2^0 * (1 + 0x199999999999aL / 0x10000000000000L).)
   *
   * <p>NOTE: In many cases, BigFraction(Double.toString(d)) may give a result closer to what the
   * user expects.
   */
  public BigFraction(double d) {
    if (Double.isInfinite(d)) throw new IllegalArgumentException("double val is infinite");
    if (Double.isNaN(d)) throw new IllegalArgumentException("double val is NaN");

    // special case - math below won't work right for 0.0 or -0.0
    if (d == 0) {
      numerator = BigInteger.ZERO;
      denominator = BigInteger.ONE;
      return;
    }

    final long bits = Double.doubleToLongBits(d);
    final int sign = (int) (bits >> 63) & 0x1;
    final int exponent = ((int) (bits >> 52) & 0x7ff) - 0x3ff;
    final long mantissa = bits & 0xfffffffffffffL;

    // number is (-1)^sign * 2^(exponent) * 1.mantissa
    BigInteger tmpNumerator = BigInteger.valueOf(sign == 0 ? 1 : -1);
    BigInteger tmpDenominator = BigInteger.ONE;

    // use shortcut: 2^x == 1 << x.  if x is negative, shift the denominator
    if (exponent >= 0) tmpNumerator = tmpNumerator.multiply(BigInteger.ONE.shiftLeft(exponent));
    else tmpDenominator = tmpDenominator.multiply(BigInteger.ONE.shiftLeft(-exponent));

    // 1.mantissa == 1 + mantissa/2^52 == (2^52 + mantissa)/2^52
    tmpDenominator = tmpDenominator.multiply(BigInteger.valueOf(0x10000000000000L));
    tmpNumerator = tmpNumerator.multiply(BigInteger.valueOf(0x10000000000000L + mantissa));

    BigInteger gcd = tmpNumerator.gcd(tmpDenominator);
    numerator = tmpNumerator.divide(gcd);
    denominator = tmpDenominator.divide(gcd);
  }
  public void testFloatToIntegral() throws Exception {
    // to byte
    assertEquals(new Byte((byte) 127), convert(new Float(127.127), Byte.class));
    assertEquals(new Byte((byte) 127), convert(new Double(127.127), Byte.class));
    assertEquals(new Byte((byte) 127), convert(new BigDecimal(127.127), Byte.class));

    // to short
    assertEquals(new Short((short) 127), convert(new Float(127.127), Short.class));
    assertEquals(new Short((short) 127), convert(new Double(127.127), Short.class));
    assertEquals(new Short((short) 127), convert(new BigDecimal(127.127), Short.class));

    // to integer
    assertEquals(new Integer(127), convert(new Float(127.127), Integer.class));
    assertEquals(new Integer(127), convert(new Double(127.127), Integer.class));
    assertEquals(new Integer(127), convert(new BigDecimal(127.127), Integer.class));

    // to long
    assertEquals(new Long(127), convert(new Float(127.127), Long.class));
    assertEquals(new Long(127), convert(new Double(127.127), Long.class));
    assertEquals(new Long(127), convert(new BigDecimal(127.127), Long.class));

    // to big integer
    assertEquals(BigInteger.valueOf(127), convert(new Float(127.127), BigInteger.class));
    assertEquals(BigInteger.valueOf(127), convert(new Double(127.127), BigInteger.class));
    assertEquals(BigInteger.valueOf(127), convert(new BigDecimal(127.127), BigInteger.class));
  }
Exemple #7
0
  public static void main(String[] args) throws Exception {
    BigInteger[] a = new BigInteger[999 + 1];
    String[] b = new String[a.length];
    long time = System.currentTimeMillis();
    a[1] = BigInteger.ZERO;
    for (int i = 2; i < a.length; i++) {
      if (i % 2 == 0) a[i] = a[i - 1].multiply(BigInteger.valueOf(2)).add(BigInteger.ONE);
      else a[i] = a[i - 1].multiply(BigInteger.valueOf(2)).subtract(BigInteger.ONE);
    }
    for (int i = 1; i < a.length; i++) {
      b[i] = a[i].toString();
    }
    System.err.println(System.currentTimeMillis() - time);

    Scanner sc = new Scanner(System.in);

    long time1 = System.currentTimeMillis();
    //		InputReader ir = new InputReader(System.in);
    while (sc.hasNext()) {
      //			int x = ir.nextInt();
      int x = sc.nextInt();
      //			if (x == -1)
      //				break;
      System.out.println(b[x]);
    }
    System.err.println(System.currentTimeMillis() - time1);
  }
  /**
   * Convenience method for converting OpenNMS enumerated ticket states to OTRS ticket StateID.
   *
   * @param state
   * @return a BigInteger representing the OTRS StateID.
   */
  private BigInteger openNMSToOTRSState(Ticket.State state) {

    BigInteger otrsStateId;

    LOG.debug("getting otrs state from OpenNMS State {}", state.toString());

    switch (state) {
      case OPEN:
        // ticket is new
        otrsStateId = BigInteger.valueOf(m_configDao.getOpenStateId());
        break;
      case CANCELLED:
        // not sure how often we see this
        otrsStateId = BigInteger.valueOf(m_configDao.getCancelledStateId());
        break;
      case CLOSED:
        // closed successful
        otrsStateId = BigInteger.valueOf(m_configDao.getClosedStateId());
        break;
      default:
        LOG.debug("No valid OpenNMS state on ticket");
        otrsStateId = BigInteger.valueOf(m_configDao.getOpenStateId());
    }

    LOG.debug("OpenNMS state was        {}", state.toString());
    LOG.debug("Setting OTRS state ID to {}", otrsStateId.toString());

    return otrsStateId;
  }
  public static void main(String args[]) {

    Scanner scan = new Scanner(System.in);
    String numS = scan.next();

    BigInteger num = new BigInteger(numS);
    ///// Numero de numeros.
    for (int i = 0; i < 100000; i++) {
      String cadenaj = "";
      int a = scan.nextInt();
      /////////////// genera la cadena mas larga con X digitos
      for (int j = 1; j <= a; j++) {

        cadenaj = cadenaj + "9";
      }

      BigInteger numero2 = new BigInteger(cadenaj);

      //////////// Genera factorial y compara si es menor

      long b = 100000;
      long m = 1;
      BigInteger factorial = BigInteger.valueOf(m);

      for (long j = 1; j <= b; j++) {
        BigInteger x = BigInteger.valueOf(j);
        factorial = factorial.multiply(x);
        if ((factorial.compareTo(numero2)) == 1) {
          System.out.println(j - 1);
          break;
        }
      }
    }
  }
/**
 * A helper class that provides utility methods related to <code>long</code> operations.
 *
 * @author Thiago T. Sá
 * @since 1.0
 */
public class LongOperations {

  /** The {@link Long} minimum value. */
  static final BigInteger bigMin = BigInteger.valueOf(Long.MIN_VALUE);

  /** The {@link Long} maximum value. */
  static final BigInteger bigMax = BigInteger.valueOf(Long.MAX_VALUE);

  /**
   * Adds two long values.
   *
   * @param x the first term.
   * @param y the second term.
   * @since 1.0
   */
  public static long saturatedAdd(long x, long y) {
    BigInteger sum = BigInteger.valueOf(x).add(BigInteger.valueOf(y));
    return bigMin.max(sum).min(bigMax).longValue();
  }

  /**
   * Multiplies two long values.
   *
   * @param x the first factor.
   * @param y the second factor.
   * @since 1.0
   */
  public static long saturatedMultiply(long x, long y) {
    BigInteger mult = BigInteger.valueOf(x).multiply(BigInteger.valueOf(y));
    return bigMin.max(mult).min(bigMax).longValue();
  }
}
Exemple #11
0
public interface ECConstants {
  public static final BigInteger ZERO = BigInteger.valueOf(0);
  public static final BigInteger ONE = BigInteger.valueOf(1);
  public static final BigInteger TWO = BigInteger.valueOf(2);
  public static final BigInteger THREE = BigInteger.valueOf(3);
  public static final BigInteger FOUR = BigInteger.valueOf(4);
}
Exemple #12
0
 /** Round the rational number up to a whole number. (Mutator) */
 public BigInteger roundUp() {
   if ((this.num.compareTo(new BigInteger("0")) == 0)) {
     return BigInteger.valueOf(0);
   } else if (this.isNegative()) {
     return this.num.divide(this.denom);
   } else return this.num.divide(this.denom).add(BigInteger.valueOf(1));
 } // roundUp()
 public static BigInteger twoPower(int num) {
   if (num == 1) {
     return BigInteger.valueOf(2);
   } else {
     return BigInteger.valueOf(2).multiply(twoPower(num - 1));
   }
 }
Exemple #14
0
  public static void testICDE() {
    // Number of total operations
    int numberOfTests = 5;
    // Length of the p, note that n=p.q
    int lengthp = 512;

    Paillier esystem = new Paillier();
    Random rd = new Random();
    PaillierPrivateKey key = KeyGen.PaillierKey(lengthp, 122333356);
    esystem.setDecryptEncrypt(key);
    // let's test our algorithm by encrypting and decrypting few instances

    long start = System.currentTimeMillis();
    for (int i = 0; i < numberOfTests; i++) {
      BigInteger m1 = BigInteger.valueOf(Math.abs(rd.nextLong()));
      BigInteger m2 = BigInteger.valueOf(Math.abs(rd.nextLong()));
      BigInteger c1 = esystem.encrypt(m1);
      BigInteger c2 = esystem.encrypt(m2);
      BigInteger c3 = esystem.multiply(c1, m2);
      c1 = esystem.add(c1, c2);
      c1 = esystem.add(c1, c3);

      esystem.decrypt(c1);
    }
    long stop = System.currentTimeMillis();
    System.out.println(
        "Running time per comparison in milliseconds: " + ((stop - start) / numberOfTests));
  }
 @Test(timeout = 5000L)
 public void powExactLongIntExact() {
   for (long base : LONGS) {
     for (int power : INTS) {
       if (power < 0) continue;
       boolean overflow =
           BigInteger.valueOf(63 - Long.numberOfLeadingZeros(Math.abs(base)))
                   .multiply(BigInteger.valueOf(power))
                   .compareTo(BigInteger.valueOf(64))
               > 0;
       BigInteger expected = overflow ? null : BigInteger.valueOf(base).pow(power);
       if (expected != null && expected.bitLength() <= 63) {
         long value = powExact(base, power);
         assertEquals(base + " ^ " + power, expected.longValue(), value);
         if (value < 10000000000000000L)
           assertEquals(
               base + " ^ " + power, power == 1 ? base : (long) 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) {
         }
       }
     }
   }
 }
Exemple #16
0
 public static char LZExtITChar(long x) {
   return (char)
       ((x < 0
               ? BigInteger.valueOf(x).add(BigInteger.valueOf(2).shiftLeft(61))
               : BigInteger.valueOf(x))
           .intValue());
 }
  @Override
  public List<RenditionData> getRenditions(
      CallContext callContext,
      String repositoryId,
      String objectId,
      String renditionFilter,
      BigInteger maxItems,
      BigInteger skipCount,
      ExtensionsData extension) {

    Lock lock = threadLockService.getReadLock(repositoryId, objectId);
    try {
      lock.lock();

      List<Rendition> renditions = contentService.getRenditions(repositoryId, objectId);

      List<RenditionData> results = new ArrayList<RenditionData>();
      for (Rendition rnd : renditions) {
        RenditionDataImpl data =
            new RenditionDataImpl(
                rnd.getId(),
                rnd.getMimetype(),
                BigInteger.valueOf(rnd.getLength()),
                rnd.getKind(),
                rnd.getTitle(),
                BigInteger.valueOf(rnd.getWidth()),
                BigInteger.valueOf(rnd.getHeight()),
                rnd.getRenditionDocumentId());
        results.add(data);
      }
      return results;
    } finally {
      lock.unlock();
    }
  }
Exemple #18
0
 public static long[] LURem(long[] x, long[] y) {
   long[] res = x.clone();
   for (int i = 0; i < res.length; ++i) {
     res[i] = BigInteger.valueOf(res[i]).divide(BigInteger.valueOf(y[i])).longValue();
   }
   return res;
 }
Exemple #19
0
  protected Pair<BigInteger, Boolean> getSizeOf(Object obj) {
    if (obj == null) return null;
    if (!(obj instanceof File)) return null;

    File f = (File) obj;
    if (f.isFile())
      return new BasicPair<BigInteger, Boolean>(BigInteger.valueOf(f.length()), false);

    if (f.isDirectory()) {
      boolean hasContinuousChild = ttable.getCachedChildren(obj) == null;
      BigInteger size = BigInteger.ZERO;

      for (TreeWalk tw : ttable.walkCachedChildren(obj, TreeWalkType.ByLevel)) {
        Object n = tw.currentNode();
        if (n instanceof ChildrenReader) {
          hasContinuousChild = true;
        } else if (n instanceof File) {
          File nf = (File) n;
          if (nf.isFile()) {
            size = size.add(BigInteger.valueOf(nf.length()));
          } else if (nf.isDirectory()) {
            if (ttable.getCachedChildren(nf) == null) {
              hasContinuousChild = true;
            }
          }
        }
      }
      return new BasicPair<BigInteger, Boolean>(size, hasContinuousChild);
    }

    return null;
  }
 @Test
 public void shouldNotFindBiggestAndSmallestPrefixWhenDoesNotExist() {
   Ipv6Range range =
       Ipv6Range.from("::").to(BigInteger.valueOf(2).pow(128).subtract(BigInteger.valueOf(2)));
   assertFalse(findMinimumPrefixForPrefixLength(range, 0).isPresent());
   assertFalse(findMaximumPrefixForPrefixLength(range, 0).isPresent());
 }
 @Override
 public BigInteger convert(Boolean source) {
   if (source) {
     return BigInteger.valueOf(101);
   }
   return BigInteger.valueOf(1);
 }
  @Test
  public void testGetVolumeWeightStockPrice() {
    Transaction localTransactionMockOne = mock(Transaction.class);
    Transaction localTransactionMockTwo = mock(Transaction.class);
    Transaction localTransactionMockThree = mock(Transaction.class);
    DateTime current = DateTime.now();
    BigDecimal expectedResult =
        new BigDecimal(41.96861852).setScale(BIG_DECIMAL_SCALE, ROUNDING_MODE);

    when(TRANSACTION_MOCK.getTimeStamp()).thenReturn(current.minusMinutes(16));
    when(TRANSACTION_MOCK.getQuantity()).thenReturn(BigInteger.valueOf(100));
    when(TRANSACTION_MOCK.getPrice()).thenReturn(new BigDecimal(3.123));
    when(localTransactionMockOne.getTimeStamp()).thenReturn(current.minusMinutes(1));
    when(localTransactionMockOne.getQuantity()).thenReturn(BigInteger.valueOf(50));
    when(localTransactionMockOne.getPrice()).thenReturn(new BigDecimal(100.3286));
    when(localTransactionMockTwo.getTimeStamp()).thenReturn(current.minusMinutes(5));
    when(localTransactionMockTwo.getQuantity()).thenReturn(BigInteger.valueOf(350));
    when(localTransactionMockTwo.getPrice()).thenReturn(new BigDecimal(34.231));
    when(localTransactionMockThree.getTimeStamp()).thenReturn(current.minusMinutes(10));
    when(localTransactionMockThree.getQuantity()).thenReturn(BigInteger.valueOf(5));
    when(localTransactionMockThree.getPrice()).thenReturn(new BigDecimal(0.0021));

    assertFalse(stockImpl.getVolumeWeightedStockPrice(15).isPresent());

    stockImpl.addTransaction(TRANSACTION_MOCK);
    stockImpl.addTransaction(localTransactionMockOne);
    stockImpl.addTransaction(localTransactionMockTwo);
    stockImpl.addTransaction(localTransactionMockThree);

    assertTrue(stockImpl.getVolumeWeightedStockPrice(15).isPresent());
    assertEquals(expectedResult, stockImpl.getVolumeWeightedStockPrice(15).get());
  }
 @Test
 public void testDivide() {
   BigInteger dividend = BigInteger.valueOf(4566746).pow(4);
   BigInteger divisor = dividend.shiftRight(7).subtract(BigInteger.valueOf(245));
   System.out.println(
       dividend
           + " / "
           + divisor
           + " = "
           + dividend.divide(divisor)
           + " rem "
           + dividend.remainder(divisor));
   System.out.println(
       "N "
           + dividend.bitLength()
           + " - D "
           + divisor.bitLength()
           + " = "
           + (dividend.bitLength() - divisor.bitLength()));
   System.out.println("Q => " + dividend.divide(divisor).bitLength());
   System.out.println("R => " + dividend.remainder(divisor).bitLength());
   System.out.println("----");
   int diff = dividend.bitLength() - divisor.bitLength();
   BigInteger n = dividend.shiftRight(divisor.bitLength());
   BigInteger d = divisor.shiftRight(divisor.bitLength() - 1);
   System.out.println(n + " / " + d + " = " + n.divide(d));
 }
  @Test
  public void testLaOne() throws InternalTranslationException, InterpreterException {
    interpreter.setRegister("$v1", BigInteger.ZERO, OperandSize.DWORD, ReilRegisterStatus.DEFINED);
    interpreter.setRegister(
        "$v2", BigInteger.valueOf(0x11223344L), OperandSize.DWORD, ReilRegisterStatus.DEFINED);

    final MockOperandTree operandTree1 = new MockOperandTree();
    operandTree1.root = new MockOperandTreeNode(ExpressionType.SIZE_PREFIX, "b4");
    operandTree1.root.m_children.add(new MockOperandTreeNode(ExpressionType.REGISTER, "$v1"));

    final MockOperandTree operandTree2 = new MockOperandTree();
    operandTree2.root = new MockOperandTreeNode(ExpressionType.SIZE_PREFIX, "b4");
    operandTree2.root.m_children.add(new MockOperandTreeNode(ExpressionType.REGISTER, "$v2"));

    final List<MockOperandTree> operands = Lists.newArrayList(operandTree1, operandTree2);

    final IInstruction instruction = new MockInstruction("move", operands);

    translator.translate(environment, instruction, instructions);

    interpreter.interpret(TestHelpers.createMapping(instructions), BigInteger.valueOf(0x100));

    // check correct outcome

    assertEquals(3, TestHelpers.filterNativeRegisters(interpreter.getDefinedRegisters()).size());
    assertEquals(BigInteger.valueOf(0x11223344L), interpreter.getVariableValue("$v1"));
    assertEquals(BigInteger.valueOf(0x11223344L), interpreter.getVariableValue("$v2"));
    assertEquals(BigInteger.ZERO, BigInteger.valueOf(interpreter.getMemorySize()));
  }
  private void getRecords(
      final int maxRecords,
      final int startPosition,
      final int totalResults,
      final int expectedNext,
      final int expectedReturn)
      throws JAXBException, UnsupportedEncodingException {
    XStream xstream = createXStream(CswConstants.GET_RECORDS_RESPONSE);
    GetRecordsType query = new GetRecordsType();
    query.setMaxRecords(BigInteger.valueOf(maxRecords));
    query.setStartPosition(BigInteger.valueOf(startPosition));
    CswRecordCollection collection = createCswRecordCollection(query, totalResults);
    collection.setStartPosition(startPosition);

    String xml = xstream.toXML(collection);

    JAXBElement<GetRecordsResponseType> jaxb =
        (JAXBElement<GetRecordsResponseType>)
            getJaxBContext()
                .createUnmarshaller()
                .unmarshal(new ByteArrayInputStream(xml.getBytes("UTF-8")));

    GetRecordsResponseType response = jaxb.getValue();
    assertThat(
        response.getSearchResults().getNumberOfRecordsMatched().intValue(), equalTo(totalResults));
    assertThat(
        response.getSearchResults().getNumberOfRecordsReturned().intValue(),
        equalTo(expectedReturn));
    //        assertThat(response.getSearchResults().getAbstractRecord().size(),
    // equalTo(expectedReturn));
    assertThat(response.getSearchResults().getNextRecord().intValue(), equalTo(expectedNext));
  }
 protected Duration getDuration(DateTimeData date) {
   int sign = 1;
   if (date.year < 0
       || date.month < 0
       || date.day < 0
       || date.hour < 0
       || date.minute < 0
       || date.second < 0) {
     sign = -1;
   }
   return datatypeFactory.newDuration(
       sign == 1,
       date.year != DatatypeConstants.FIELD_UNDEFINED
           ? BigInteger.valueOf(sign * date.year)
           : null,
       date.month != DatatypeConstants.FIELD_UNDEFINED
           ? BigInteger.valueOf(sign * date.month)
           : null,
       date.day != DatatypeConstants.FIELD_UNDEFINED ? BigInteger.valueOf(sign * date.day) : null,
       date.hour != DatatypeConstants.FIELD_UNDEFINED
           ? BigInteger.valueOf(sign * date.hour)
           : null,
       date.minute != DatatypeConstants.FIELD_UNDEFINED
           ? BigInteger.valueOf(sign * date.minute)
           : null,
       date.second != DatatypeConstants.FIELD_UNDEFINED
           ? new BigDecimal(String.valueOf(sign * date.second))
           : null);
 }
  public static void main(String args[]) throws IOException {

    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    while (true) {

      String str = in.readLine();

      //     Scanner in = new Scanner(System.in);

      if (str == null) {
        break;
      } else {
        BigInteger num = new BigInteger(str);

        if (str.equals("0") || str.equals("1")) {
          System.out.println(str);
        } else {
          //        BigInteger num = new BigInteger(str);
          //
          // System.out.println(num.subtract(BigInteger.ONE).multiply(BigInteger.valueOf(2)));
          System.out.println(num.multiply(BigInteger.valueOf(2)).subtract(BigInteger.valueOf(2)));
        }
      }
    }
  }
 @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) {
         }
       }
     }
   }
 }
Exemple #29
0
  static {
    // TODO: DecimalFormat uses ROUND_HALF_EVEN, not ROUND_HALF_UP
    // Float: precision of 7 (6 digits after .)
    floatFormatter = new DecimalFormat();
    floatFormatter.applyPattern("0.######E0");

    // Double: precision of 16 (15 digits after .)
    doubleFormatter = new DecimalFormat();
    doubleFormatter.applyPattern("0.###############E0");

    bigIntTenPow = new BigInteger[20];
    bigIntMinUnscaled = new BigInteger[20];
    bigIntMaxUnscaled = new BigInteger[20];

    for (int i = 0; i < bigIntTenPow.length; i++) {
      bigIntTenPow[i] = bigIntTen.pow(i);
      if (i < 19) {
        bigIntMaxUnscaled[i] = bigIntTenPow[i].subtract(BigInteger.ONE);
        bigIntMinUnscaled[i] = bigIntMaxUnscaled[i].negate();
      } else {
        bigIntMaxUnscaled[i] = BigInteger.valueOf(Long.MAX_VALUE);
        bigIntMinUnscaled[i] = BigInteger.valueOf(Long.MIN_VALUE);
      }
    }
  }
 private void parsePaymentRequest(Protos.PaymentRequest request) throws PaymentRequestException {
   try {
     if (request == null) throw new PaymentRequestException("request cannot be null");
     if (!request.hasPaymentDetailsVersion())
       throw new PaymentRequestException.InvalidVersion("No version");
     if (request.getPaymentDetailsVersion() != 1)
       throw new PaymentRequestException.InvalidVersion(
           "Version 1 required. Received version " + request.getPaymentDetailsVersion());
     paymentRequest = request;
     if (!request.hasSerializedPaymentDetails())
       throw new PaymentRequestException("No PaymentDetails");
     paymentDetails =
         Protos.PaymentDetails.newBuilder()
             .mergeFrom(request.getSerializedPaymentDetails())
             .build();
     if (paymentDetails == null) throw new PaymentRequestException("Invalid PaymentDetails");
     if (!paymentDetails.hasNetwork()) params = MainNetParams.get();
     else params = NetworkParameters.fromPmtProtocolID(paymentDetails.getNetwork());
     if (params == null)
       throw new PaymentRequestException.InvalidNetwork(
           "Invalid network " + paymentDetails.getNetwork());
     if (paymentDetails.getOutputsCount() < 1)
       throw new PaymentRequestException.InvalidOutputs("No outputs");
     for (Protos.Output output : paymentDetails.getOutputsList()) {
       if (output.hasAmount()) totalValue = totalValue.add(BigInteger.valueOf(output.getAmount()));
     }
     // This won't ever happen in practice. It would only happen if the user provided outputs
     // that are obviously invalid. Still, we don't want to silently overflow.
     if (totalValue.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0)
       throw new PaymentRequestException.InvalidOutputs("The outputs are way too big.");
   } catch (InvalidProtocolBufferException e) {
     throw new PaymentRequestException(e);
   }
 }