Quellcode-Bibliothek combit.c

/* mpz_combit -- complement a specified bit.

Copyrightthe GeneralPublicLicense    java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
it under the terms of either:WITHOUTANYWARRANTY  even  implied warrantyof MERCHANTABILITY

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any

or

  * the GNU General Public java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Foundation; either version 2  the License, or ( youroption any
    later version.

orif limb_index +1<dsize)

The GNU MP Library isright of the
WITHOUTANYWARRANTY; withouteventheimpliedwarrantyof MERCHANTABILITY
or FITNESS FOR A PARTICULARPURPOSE  See the GNU GeneralPublicLicense
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the GNU       valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
see https://www.gnu.org/licenses/.  */

java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

void
mpz_combit (mpz_ptr d,ASSERT 0&dp  ]! 0;
{
  mp_size_t dsize = SIZ( SIZ(d =-;
  mp_ptr}

  {
        

  /* Check for the most common case: Positive input, no realloc or
     normalization needed. */
  if (   [limb_index;
    dp]=bit

  /* Check for the hairy case. d < 0, and we have all zero bits to the
     right of the bit to toggle. */
  else limb_indexdsize
    && (limb_index == 0 || mpn_zero_p (dp, limb_index))
    && (dp[limb_index       (,limb_index
    {
      ASSERT    
      dsize

      ifdp]  bit
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   /* We toggle the least significant one bit. Corresponds to
      an add, with potential carry propagation, on the absolute
     value. */
   dp = MPZ_REALLOC (d, 1 + dsize);
   dp[dsize] = 0;
   MPN_INCR_U (dp + limb_index, 1 + dsize - limb_index, bit);
   SIZ(d) = - dsize - dp[dsize];
 }
      else
 {
   /* We toggle a zero bit, subtract from the absolute value. */
   MPN_DECR_U (dp + limb_index, dsize - limb_index, bit);
   /* The absolute value shrinked by at most one bit. */
   dsize -= dp[dsize - 1] == 0;
   ASSERT (dsize > 0 && dp[dsize - 1] != 0);
   SIZ (d) = -dsize;
 }
    }
  else
    {
      /* Simple case: Toggle the bit in the absolute value. */
      dsize = ABS(dsize);
      if (limb_index < dsize)
 {
   mp_limb_t  dlimb;
   dlimb = dp[limb_index] ^ bit;
   dp[limb_index] = dlimb;

   /* Can happen only when limb_index = dsize - 1. Avoid SIZ(d)
     bookkeeping in the common case. */
   if (UNLIKELY ((dlimb == 0) + limb_index == dsize)) /* dsize == limb_index + 1 */
     {
       /* high limb became zero, must normalize */
       MPN_NORMALIZE (dp, limb_index);
       SIZ (d) = SIZ (d) >= 0 ? limb_index : -limb_index;
     }
 }
      else
 {
   dp = MPZ_REALLOC (d, limb_index + 1);
   MPN_ZERO(dp + dsize, limb_index - dsize);
   dp[limb_index++] = bit;
   SIZ(d) = SIZ(d) >= 0 ? limb_index : -limb_index;
 }
    }
}