数学计算

开发平台：
Unix_Linux

import.c：源码内容
							/* mpz_import -- set mpz from word data.
Copyright 2002 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 3 of the License, or (at your
option) any later version.
The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
#include <stdio.h>
#include "gmp.h"
#include "gmp-impl.h"
#if HAVE_LIMB_BIG_ENDIAN
#define HOST_ENDIAN     1
#endif
#if HAVE_LIMB_LITTLE_ENDIAN
#define HOST_ENDIAN     (-1)
#endif
#ifndef HOST_ENDIAN
static const mp_limb_t  endian_test = (CNST_LIMB(1) << (GMP_LIMB_BITS-7)) - 1;
#define HOST_ENDIAN     (* (signed char *) &endian_test)
#endif
void
mpz_import (mpz_ptr z, size_t count, int order,
            size_t size, int endian, size_t nail, const void *data)
{
  mp_size_t  zsize;
  mp_ptr     zp;
  ASSERT (order == 1 || order == -1);
  ASSERT (endian == 1 || endian == 0 || endian == -1);
  ASSERT (nail <= 8*size);
  zsize = (count * (8*size - nail) + GMP_NUMB_BITS-1) / GMP_NUMB_BITS;
  MPZ_REALLOC (z, zsize);
  zp = PTR(z);
  if (endian == 0)
    endian = HOST_ENDIAN;
  /* Can't use these special cases with nails currently, since they don't
     mask out the nail bits in the input data.  */
  if (nail == 0 && GMP_NAIL_BITS == 0)
    {
      unsigned  align = ((char *) data - (char *) NULL) % sizeof (mp_limb_t);
      if (order == -1
          && size == sizeof (mp_limb_t)
          && endian == HOST_ENDIAN
          && align == 0)
        {
          MPN_COPY (zp, (mp_srcptr) data, (mp_size_t) count);
          goto done;
        }
      if (order == -1
          && size == sizeof (mp_limb_t)
          && endian == - HOST_ENDIAN
          && align == 0)
        {
          MPN_BSWAP (zp, (mp_srcptr) data, (mp_size_t) count);
          goto done;
        }
      if (order == 1
          && size == sizeof (mp_limb_t)
          && endian == HOST_ENDIAN
          && align == 0)
        {
          MPN_REVERSE (zp, (mp_srcptr) data, (mp_size_t) count);
          goto done;
        }
    }
  {
    mp_limb_t      limb, byte, wbitsmask;
    size_t         i, j, numb, wbytes;
    mp_size_t      woffset;
    unsigned char  *dp;
    int            lbits, wbits;
    numb = size * 8 - nail;
    /* whole bytes to process */
    wbytes = numb / 8;
    /* partial byte to process */
    wbits = numb % 8;
    wbitsmask = (CNST_LIMB(1) << wbits) - 1;
    /* offset to get to the next word after processing wbytes and wbits */
    woffset = (numb + 7) / 8;
    woffset = (endian >= 0 ? woffset : -woffset)
      + (order < 0 ? size : - (mp_size_t) size);
    /* least significant byte */
    dp = (unsigned char *) data
      + (order >= 0 ? (count-1)*size : 0) + (endian >= 0 ? size-1 : 0);
#define ACCUMULATE(N)                                   
    do {                                                
      ASSERT (lbits < GMP_NUMB_BITS);                   
      ASSERT (limb <= (CNST_LIMB(1) << lbits) - 1);     
                                                        
      limb |= (mp_limb_t) byte << lbits;                
      lbits += (N);                                     
      if (lbits >= GMP_NUMB_BITS)                       
        {                                               
          *zp++ = limb & GMP_NUMB_MASK;                 
          lbits -= GMP_NUMB_BITS;                       
          ASSERT (lbits < (N));                         
          limb = byte >> ((N) - lbits);                 
        }                                               
    } while (0)
    limb = 0;
    lbits = 0;
    for (i = 0; i < count; i++)
      {
        for (j = 0; j < wbytes; j++)
          {
            byte = *dp;
            dp -= endian;
            ACCUMULATE (8);
          }
        if (wbits != 0)
          {
            byte = *dp & wbitsmask;
            dp -= endian;
            ACCUMULATE (wbits);
          }
        dp += woffset;
      }
    if (lbits != 0)
      {
        ASSERT (lbits <= GMP_NUMB_BITS);
        ASSERT_LIMB (limb);
        *zp++ = limb;
      }
    ASSERT (zp == PTR(z) + zsize);
    /* low byte of word after most significant */
    ASSERT (dp == (unsigned char *) data
            + (order < 0 ? count*size : - (mp_size_t) size)
            + (endian >= 0 ? (mp_size_t) size - 1 : 0));
  }
 done:
  zp = PTR(z);
  MPN_NORMALIZE (zp, zsize);
  SIZ(z) = zsize;
}

						