Variable Precision Integer Arithmetic: bin2vpi(B) - File Exchange

Code covered by the BSD License

Highlights from
Variable Precision Integer Arithmetic

demo_vpi
base2vpi(B,base) bin2vpi: converts an integer in an arbitrary base into vpi (decimal) form
bin2vpi(B) bin2vpi: converts a binary representation of an integer into vpi (decimal) form
binomfactors(n,k) binomfactors: list all factors of the binomial coefficient nchoosek(n,k)
catdigits(N,M) catdigits: concatenates the digits of N and M into an aggregate number
createPrimesList createPrimesList - For users of older matlab releases, this function will generate a compatible _primeslist_ file
factorialfactors(n) factorialfactors: efficient computation of the prime factors of factorial(n)
fibonacci(n) fibonacci: vpi tool to efficiently compute the n'th Fibonacci number and the n'th Lucas number
getprimeslist loads the primeslist file, and decompresses it, returning the list of primes up to 2^26
ispalindrome(N) ispalindrome: test if the number N (vpi or numeric, or a digit string as a vector) is a palindrome
iszero(INT) vpi/iszero: test to see if a numeric object is zero
legendresymbol(a,p) legendresymbol: computes the legendre symbol (a/p) for prime p
lineardiophantine(A,B,C) lineardiophantine: solve the linear Diophantine equation, A*x + B*y = C
mersenne(p) mersenne: identify whether 2^p-1 is a Mersenne prime, using the Lucas-Lehmer test
minv(a,p)
modfibonacci(n,modulus) fibonacci: compute the n'th Fibonacci number and the n'th Lucas number, all modulo a given value
modrank(A,p) modrank: compute the rank of an integer array, modulo p
modroot(a,p)
modsolve(A,rhs,p)
nextprime(N,direction,kprimes) nextprime: finds the next larger prime number directly above (or below) N
numberOfPartitions(N) numberOfPartitions: compute the number of partitions of the positive integer n
powermod(a,d,n) vpi/powermod: Compute mod(a^d,n)
quadraticresidues(N) quadraticresidues: returns a list of the possible quadratic residues of the integer N
quotient(numerator,denominato... quotient: divides two integers, computing a quotient and remainder
subfactorial(N) subfactorial: The subfactorial of an integer (or integers) N, known as !N
totient(N) vpi/totient: the number of positive integers less than N that are coprime to N
vpi(N) vpi: Creator function for a variable precision integer
View all files

from Variable Precision Integer Arithmetic by John D'Errico
Arithmetic with integers of fully arbitrary size. Arrays and vectors of vpi numbers are supported.

bin2vpi(B)

function INT = bin2vpi(B)
% bin2vpi: converts a binary representation of an integer into vpi (decimal) form
% usage: INT = bin2vpi(B)
%
% arguments: (input)
%  N - boolean vector or character string, contains
%      the digits of a binary number, either as a
%      numeric vector
%
% arguments: (output)
%  INT - the vpi form of the integer represented by N
%
%
% Example:
%  bin2vpi('1010101')
%  ans =
%      85
%
%
%  bin2vpi([1 0 1 0 1 0 1])
%  ans =
%      85
%
%
%  See also: base2dec, dec2base, vpi2base, base2vpi, vpi2bin
%  
% 
%  Author: John D'Errico
%  e-mail: woodchips@rochester.rr.com
%  Release: 1.0
%  Release date: 1/24/09


% insure that B is a vector
if (nargin~=1) || isempty(B) || ~isvector(B)
  error('B must be a boolean or character vector')
end

% is B boolean or character?
if ischar(B)
  % verify that B contains only '0' or '1' characters
  if ~all(ismember(B,'01'))
    error('If B is character, it must be built from only ''0'' and ''1'' characters')
  end
  
  % convert to boolean
  B = (B=='1');
elseif isnumeric(B)
  if ~all(ismember(B,[0 1]))
    error('If B is numeric, it must be built from only 0 and 1 elements')
  end
else
  error('B must be a boolean vector or a character vector')
end

% flip the vector, so we will start
% with the lowest order bits and work up.
B = fliplr(B(:)');

% initialize INT at zero. we will add in any other powers
% as necessary.
INT = vpi(0);
% some other useful numbers
two = vpi(2);
blocksize = 50;

% dec2bin wants a character string
Bchar = '01';
b2d = @(block) bin2dec(Bchar(fliplr(block)+1));

bs2 = two.^blocksize;
offset = vpi(1);
while ~isempty(B)
  if length(B) <= blocksize
    % shorten the last block down to fit 
    blocksize = length(B);
  end
  % nibbling off one chunk at a time of B
  block = B(1:blocksize);
  block = b2d(block);
  INT = INT + block*offset;
  
  B(1:blocksize) = [];
  offset = offset*bs2;
end

Highlights from Variable Precision Integer Arithmetic

Highlights from
Variable Precision Integer Arithmetic