src/N.Binary.cpp

00001 #include <symbolism/N.h>
00002 
00003 namespace symbolism {
00004 namespace ring {
00005 
00006 void N::left_shift_large(const N& a, unsigned int count)
00007 {
00008     size_t climbs = count / bits_per_limb;
00009     unsigned int cbits = count % bits_per_limb;
00010 
00011     reserve(a.size + climbs);
00012     if(cbits)
00013     {
00014         limb_t carry = mpn_lshift(&data[climbs], a.data, a.size + 1, cbits);
00015         add_carry_large(carry);
00016     }
00017     else
00018     {
00019         for(size_t i=size; i >= climbs; i--)
00020         {
00021             data[i] = a.data[i - climbs];
00022         }
00023     }
00024     for(size_t i=0; i < climbs; i++)
00025     {
00026         data[i] = 0;
00027     }
00028 }
00029 
00030 void N::left_shift_large(unsigned int count)
00031 {
00032     size_t climbs = count / bits_per_limb;
00033     unsigned int cbits = count % bits_per_limb;
00034 
00035     if(cbits)
00036     {
00037         limb_t carry;
00038         resize_large(size + climbs);
00039         limb_t* target = data + climbs;
00040         carry = mpn_lshift(target, data, size - climbs + 1, cbits);
00041         add_carry_large(carry);
00042     }
00043     else if(climbs)
00044     {
00045         resize_large(size + climbs);
00046         for(size_t i = size; i >= climbs; i--)
00047         {
00048             data[i] = data[i - climbs];
00049         }
00050     }
00051     for(size_t i = 0; i < climbs; i++)
00052     {
00053         data[i] = 0;
00054     }
00055 }
00056 
00057 void N::right_shift_large(const N& a, unsigned int count)
00058 {
00059     size_t climbs = count / bits_per_limb;
00060     unsigned int cbits = count % bits_per_limb;
00061 
00062     reserve(a.size - climbs);
00063     if(size)
00064     {
00065         if(cbits)
00066         {
00067             limb_t* source = a.data + climbs;
00068             mpn_rshift(data, source, a.size + 1 - climbs, cbits);
00069         }
00070         else
00071         {
00072             for(size_t i=0; i <= size; i++)
00073             {
00074                 data[i] = a.data[i + climbs];
00075             }
00076         }
00077     }
00078     else
00079     {
00080         limb = a.data[climbs] >> cbits;
00081     }
00082     normalize();
00083 }
00084 
00085 void N::right_shift_large(unsigned int count)
00086 {
00087     size_t climbs = count / bits_per_limb;
00088     unsigned int cbits = count % bits_per_limb;
00089 
00090     if(climbs)
00091     {
00092         for(size_t i=0; i <= size - climbs; i++)
00093         {
00094             data[i] = data[i + climbs];
00095         }
00096     }
00097     if(cbits)
00098     {
00099         mpn_rshift(data, &data[climbs], size + 1 - climbs, cbits);
00100     }
00101     normalize();
00102 }
00103 
00104 }}

Copyright © 2007-2008 Remco Bloemen.

Generated on Tue Jan 22 17:35:31 2008 for symbolism by doxygen 1.5.4

Hosted by SourceForge.net Logo