bcbitwise.php

   1 <?php
   2
   3 // Bitwise math of arbitrary precision numbers.
   4 // From http://cct.me.ntut.edu.tw/chchting/aiahtm/computer/phphelp/ref.bc.php.htm
   5
   6 // MAX_BASE is the maximum base that can be represented in
   7 // one byte on the host machine. On most modern systems, this
   8 // value can be 256, but if there are still any systems with 7-bit
   9 // bytes out there, you should use 128 for maximum
  10 // portability.
  11
  12 define('MAX_BASE', 256);
  13
  14 //// INTERFACE ROUTINES:
  15
  16 // Bitwise AND
  17
  18 function bcand($x, $y)
  19 {
  20         return _bcbitwise_internal($x, $y, '_bcand');
  21 }
  22
  23 // Bitwise OR
  24
  25 function bcor($x, $y)
  26 {
  27         return _bcbitwise_internal($x, $y, '_bcor');
  28 }
  29
  30 // Bitwise XOR
  31
  32 function bcxor($x, $y)
  33 {
  34         return _bcbitwise_internal($x, $y, '_bcxor');
  35 }
  36
  37 // Left shift (<<)
  38
  39 function bcleftshift($num, $shift)
  40 {
  41         return bcmul($num, bcpow(2, $shift), 0);
  42 }
  43
  44 // Right shift (>>)
  45
  46 function bcrightshift($num, $shift)
  47 {
  48         return bcdiv($num, bcpow(2, $shift), 0);
  49 }
  50
  51 // Convert decimal to hex (like PHP's builtin dechex)
  52
  53 function bcdechex($num)
  54 {
  55   $res = "";
  56   while ($num != '0') {
  57     $byte = bcand($num, 255);
  58     $hex = dechex($byte);
  59     if (strlen($hex) == 1) $hex = '0' . $hex;
  60     $res = $hex . $res;
  61     $num = bcrightshift($num, 8);
  62   }
  63   if ($res == '') $res = 0;
  64   return $res;
  65 }
  66
  67 // Convert hex to decimal (like PHP's builtin hexdec)
  68
  69 function bchexdec($hex) {
  70   $res = 0;
  71   for ($i=0; $i<strlen($hex); $i++) {
  72     $res = bcadd(bcleftshift($res, 4), hexdec($hex[$i]));
  73   }
  74   return $res;
  75 }
  76
  77 // Convert args from hex and result to hex of a bcxxx operation.
  78
  79 function bcashex($operation, $x, $y) {
  80   $x = bchexdec($x);
  81   $y = bchexdec($y);
  82   return bcdechex($operation($x, $y));
  83 }
  84
  85 // Hex version of all the operators
  86
  87 function bcandhex($x, $y) {
  88   return bcashex('bcand', $x, $y);
  89 }
  90
  91 function bcorhex($x, $y) {
  92   return bcashex('bcor', $x, $y);
  93 }
  94
  95 function bcxorhex($x, $y) {
  96   return bcashex('bcxor', $x, $y);
  97 }
  98
  99 function bcleftshifthex($x, $y) {
 100   return bcashex('bcleftshift', $x, $y);
 101 }
 102
 103 function bcrightshifthex($x, $y) {
 104   return bcashex('bcrightshift', $x, $y);
 105 }
 106
 107 function bcaddhex($x, $y) {
 108   return bcashex('bcadd', $x, $y);
 109 }
 110
 111 function bcsubhex($x, $y) {
 112   return bcashex('bcsub', $x, $y);
 113 }
 114
 115 function bcmulhex($x, $y) {
 116   return bcashex('bcmul', $x, $y);
 117 }
 118
 119 function bcdivhex($x, $y) {
 120   return bcashex('bcdiv', $x, $y);
 121 }
 122
 123
 124 //// INTERNAL ROUTINES
 125
 126 // These routines operate on only one byte. They are used to
 127 // implement _bcbitwise_internal.
 128
 129 function _bcand($x, $y)
 130 {
 131         return $x & $y;
 132 }
 133
 134 function _bcor($x, $y)
 135 {
 136         return $x | $y;
 137 }
 138
 139 function _bcxor($x, $y)
 140 {
 141         return $x ^ $y;
 142 }
 143
 144 // _bcbitwise_internal - The majority of the code that implements
 145 //                       the bitwise functions bcand, bcor, and bcxor.
 146 //
 147 // arguments           - $x and $y are the operands (in decimal format),
 148 //                       and $op is the name of one of the three
 149 //                       internal functions, _bcand, _bcor, or _bcxor.
 150 //
 151 //
 152 // see also            - The interfaces to this function: bcand, bcor,
 153 //                       and bcxor
 154
 155 function _bcbitwise_internal($x, $y, $op)
 156 {
 157         $bx = bc2bin($x);
 158         $by = bc2bin($y);
 159
 160         // Pad $bx and $by so that both are the same length.
 161
 162         equalbinpad($bx, $by);
 163
 164         $ix=0;
 165         $ret = '';
 166
 167         for($ix = 0; $ix < strlen($bx); $ix++)
 168         {
 169                 $xd = substr($bx, $ix, 1);
 170                 $yd = substr($by, $ix, 1);
 171                 $ret .= call_user_func($op, $xd, $yd);
 172         }
 173
 174         return bin2bc($ret);
 175 }
 176
 177 // equalbinpad - Pad the operands on the most-significant end
 178 //               so they have the same number of bytes.
 179 //
 180 // arguments   - $x and $y, binary-format numbers (converted
 181 //               from decimal format with bc2bin()), passed
 182 //               by reference.
 183 //
 184 // notes       - Both operands are modified by this function.
 185
 186 function equalbinpad(&$x, &$y)
 187 {
 188         $xlen = strlen($x);
 189           $ylen = strlen($y);
 190
 191         $length = max($xlen, $ylen);
 192           fixedbinpad($x, $length);
 193         fixedbinpad($y, $length);
 194 }
 195
 196 // fixedbinpad - Pad a binary number up to a certain length
 197 //
 198 // arguments   - $num: The operand to be padded.
 199 //
 200 //             - $length: The desired minimum length for
 201 //                        $num
 202 //
 203 // notes       - $num is modified by this function.
 204
 205 function fixedbinpad(&$num, $length)
 206 {
 207         $pad = '';
 208         for($ii = 0; $ii < $length-strlen($num); $ii++)
 209         {
 210                 $pad .= bc2bin('0');
 211         }
 212
 213         $num = $pad . $num;
 214 }
 215
 216 // bc2bin       - Convert a decimal number to the internal
 217 //                binary format used by this library.
 218 //
 219 // return value - The binary representation of $num.
 220
 221 function bc2bin($num)
 222 {
 223         return dec2base($num, MAX_BASE);
 224 }
 225
 226 // bin2bc       - Reverse of bc2bin
 227
 228 function bin2bc($num)
 229 {
 230         return base2dec($num, MAX_BASE);
 231 }
 232
 233 // convert a decimal value to any other base value
 234 function dec2base($dec,$base,$digits=FALSE) {
 235     if($base<2 or $base>256) die("Invalid Base: ".$base);
 236     bcscale(0);
 237     $value="";
 238     if(!$digits) $digits=digits($base);
 239     while($dec>$base-1) {
 240         $rest=bcmod($dec,$base);
 241         $dec=bcdiv($dec,$base);
 242         $value=$digits[$rest].$value;
 243     }
 244     $value=$digits[intval($dec)].$value;
 245     return (string) $value;
 246 }
 247
 248 // convert another base value to its decimal value
 249 function base2dec($value,$base,$digits=FALSE) {
 250     if($base<2 or $base>256) die("Invalid Base: ".$base);
 251     bcscale(0);
 252     if($base<37) $value=strtolower($value);
 253     if(!$digits) $digits=digits($base);
 254     $size=strlen($value);
 255     $dec="0";
 256     for($loop=0;$loop<$size;$loop++) {
 257         $element=strpos($digits,$value[$loop]);
 258         $power=bcpow($base,$size-$loop-1);
 259         $dec=bcadd($dec,bcmul($element,$power));
 260     }
 261     return (string) $dec;
 262 }
 263
 264 function digits($base) {
 265     if($base>64) {
 266         $digits="";
 267         for($loop=0;$loop<256;$loop++) {
 268             $digits.=chr($loop);
 269         }
 270     } else {
 271         $digits ="0123456789abcdefghijklmnopqrstuvwxyz";
 272         $digits.="ABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
 273     }
 274     $digits=substr($digits,0,$base);
 275     return (string) $digits;
 276 }
 277
 278 /* ***** BEGIN LICENSE BLOCK *****
 279  * Version: MPL 1.1/GPL 2.0/LGPL 2.1/Apache 2.0
 280  *
 281  * The contents of this file are subject to the Mozilla Public License Version
 282  * 1.1 (the "License"); you may not use this file except in compliance with
 283  * the License. You may obtain a copy of the License at
 284  * http://www.mozilla.org/MPL/
 285  *
 286  * Software distributed under the License is distributed on an "AS IS" basis,
 287  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 288  * for the specific language governing rights and limitations under the
 289  * License.
 290  *
 291  * The Original Code is LoomClient PHP library
 292  *
 293  * The Initial Developer of the Original Code is
 294  * Bill St. Clair.
 295  * Portions created by the Initial Developer are Copyright (C) 2008
 296  * the Initial Developer. All Rights Reserved.
 297  *
 298  * Contributor(s):
 299  *   Bill St. Clair <bill@billstclair.com>
 300  *
 301  * Alternatively, the contents of this file may be used under the
 302  * terms of the GNU General Public License Version 2 or later (the
 303  * "GPL"), the GNU Lesser General Public License Version 2.1 or later
 304  * (the "LGPL"), or The Apache License Version 2.0 (the "AL"), in
 305  * which case the provisions of the GPL, LGPL, or AL are applicable
 306  * instead of those above. If you wish to allow use of your version of
 307  * this file only under the terms of the GPL, the LGPL, or the AL, and
 308  * not to allow others to use your version of this file under the
 309  * terms of the MPL, indicate your decision by deleting the provisions
 310  * above and replace them with the notice and other provisions
 311  * required by the GPL or the LGPL. If you do not delete the
 312  * provisions above, a recipient may use your version of this file
 313  * under the terms of any one of the MPL, the GPL the LGPL, or the AL.
 314  ****** END LICENSE BLOCK ***** */
 315 ?>