GVSU MTH 225 Lecture-Module #09: Some Functions on Integers

MTH 225 Lecture-Module #09:
Some Functions on Integers

binary representation of integers

(Section 3.6 of our textbook)

need to know this material to be able to understand how computers encode all data

well, remembering back to ,
what is the interpretation of our normal decimal i.e. base-ten representation of integers?
digits are
e.g. 397_ten has 3 in 100s place, 9 in 10s place, 7 in 1s place
i.e. 397_ten ==
I use notation "d_i" for the digit in the 10ⁱ place
e.g. for 397_ten, d₀ = , d₁ = , d₂ =

why might decimal representation concern any of you now?
well, someone has to implement Integer.toString(int)
which depends on handling (individual) digits — what if it's you?

public class ... {
    public static void main(String[] args) {
        int n_given = new Random() .nextInt(1000);
        System.out.println("n_given's digit d0: " + digit(n_given, 0));
        System.out.println("n_given's digit d1: " + digit(n_given, 1));
        System.out.println("n_given's digit d2: " + digit(n_given, 2));
        }

for each of a given number n_given's digits d_i corresponding to our base's powers 10ⁱ,
d_i := |_n_given / 10ⁱ_| mod 10

    public static int digit(int n_given, int place) {
         return  n_given / Math.pow(10, place)  %  10;


        }
    }

e.g. |_397 / 10⁰_| mod 10 := |_397/_| mod 10 := |__| mod 10 := which is d₀
e.g. |_397 / 10¹_| mod 10 := |_397/_| mod 10 := |__| mod 10 := mod 10 := which is d₁
e.g. |_397 / 10²_| mod 10 := |_397/_| mod 10 := |__| mod 10 := mod 10 := which is d₂

anyway, people(/computers) have used and still use some bases other than ten

ancient Babylonians used base sixty(!)
sounds silly; do you do anything like that?

various LINUX/UNIX utilities such as access control use
base-eight representation called
for base eight, digits are
e.g. 162_eight == 1*8² + 6*8¹ + 2*8⁰
== _ten + _ten + _ten
== _ten

and Computer Science also uses hexadecimal which is base
used for compactness and convenient conversion with the following base:

fundamental base Computer Science uses is
ultimately because it's easiest to build machines processing data represented this way
this was an insight of in 1945:

The all-or-none, two-equilibrium arrangements [of electronic components] are [best]. [Then] it is natural to use a system of arithmetic in which the digits are also two-valued.
"First Draft of a &Report on the EDVAC [Electronic Discrete Variable Automatic Computer]"

in that paper, von Neumann specified further basic features for design of computers
e.g. central arithmetic unit, memory, stored program, ...
all computers now conform to that design called "von Neumann architecture"

anyway,
base-two arithmetic called
for base two, digits are only
abbreviates "binary digit"
e.g. 110_two has 1 in 2² place, 1 in 2¹ place, 0 in 2⁰ place
i.e. 110_two == 1*2² + 1*2¹ + 0*2⁰
==  _ten + _ten + _ten
==  _ten
(reversing:   _ten == 110_two)
e.g. 1001011_two has 1 in 2⁶ place, 0 in 2⁵ place, 0 in 2⁴ place, ...
i.e. 1001011_two == 1*2⁶ + 0*2⁵ + 0*2⁴ + 1*2³ + 0*2² + 1*2¹ + 1*2⁰
==  _ten +                  + _ten +         + _ten + _ten
==  _ten
thus can obtain decimal representation of a number presented in binary

like with base ten above,
for each of a given number n_given's binary digits b_i corresponding to powers 2ⁱ,
e.g. for 1001011_two, b₀ = , b₁ = , b₂ = ,
b₃ = , b₄ = , b₅ = , b₆ =
b_i := |_n_given / 2ⁱ_| mod 2
(for not-quite-up-to-date Web-browsers: ... |_ n_given / 2ⁱ _| ...)
e.g. for b₀ |_75 / 2⁰_| mod 2 := |_75/_| mod 2 := |__| mod 2 := which is b₀
e.g. for b₁ |_75 / 2¹_| mod 2 := |_75/_| mod 2 := |__| mod 2 := mod 2 := which is b₁
e.g. for b₂ |_75 / 2²_| mod 2 := |_75/_| mod 2 := |__| mod 2 := mod 2 := which is b₂
incidentally, notice that |_75 / 2²_| == |_|_75 / 2¹_| / 2_|
and we had already calculated |_75 / 2¹_|
generally, |_u / v^x+1_| == |_|_u / v^x_| / v_|
(as u/v^x+1 == (u/v^x)/v )
enabling us to do these evaluations more easily as follows:
e.g. |_75 / 2³_| mod 2 := |_|_75 / 2²_| / 2_| mod 2 := |_ / 2_| mod 2 := |__| mod 2 := mod 2 := which is b₃
e.g. |_75 / 2⁴_| mod 2 := |_|_75 / 2³_| / 2_| mod 2 := |_ / 2_| mod 2 := mod 2 := which is b₄
e.g. |_75 / 2⁵_| mod 2 := |_|_75 / 2⁴_| / 2_| mod 2 := |_ / 2_| mod 2 := mod 2 := which is b₅
e.g. |_75 / 2⁶_| mod 2 := |_|_75 / 2⁵_| / 2_| mod 2 := |_ / 2_| mod 2 := mod 2 := which is b₆

such processing actually provides one algorithm for obtaining binary representation of a number presented in decimal
here's ≈Java encoding of this algorithm:
(≈p.221 in our textbook)

    void base_2_expansion(int n, int[] b) {    // resulting bits stored in |b[]|
                                            // i.e. this code will set |b[]|
                                            // to be {...,1,0,1,1,0,0,...}
                                            // as appropriate
        // let |n_given| denote the initial given value for e
        int k = 0;
        while ( n > 0 ) {
            // at this point n == Ln_given/2ⁿR
            b[k] = n % 2;

            n = n/2;    // in Java, division of |int|s automatically does floor
                        // so this statement |n = n/2;| resets n
                        // to: |_|_n_given / 2^k_| / 2_|
                        // which is: |_n_given / 2^(k+1)_|
            k = k + 1;  // then with k changed here to k + 1,
                        // n == |_n_given / 2^k_| for the new k
            }
        // assume |b[]| otherwise contains zeroes
        }

an English presentation of the preceding algorithm for obtaining binary representation of a nonnegative number n is as follows:

    until n is 0, repeatedly do the following:
        * write 1 if n is odd or 0 if n is even
        * divide n by 2, discarding any fractional part or remainder
    the result is the REVERSE of the 1s and 0s that you wrote

e.g. for 75:

e.g. for :

an alternative algorithm is as follows:

    * write all the powers of two until reach (or pass) n
    * for each power of two 2^k here, going from large down to small:
        + if 2^k > n, write a 0
        + otherwise, write a 1 and subtract p from n
    the result is the sequence of 1s and 0s in the order written

e.g. for 75:

e.g. for :

application of binary representation of integers:
repeated squaring algorithm good way to do exponentiation

a straightforward way to do exponentiation is as follows:
the following code is supposed to return a^e:

int exponentiation(int a, int e) {
     // a * a * a * ... * a          e times
 int result = 1;
 while ( e-- > 0 )
     result *= a;
 return  result;

    }

note loop repeats e times
thus do operations in the loop such as the important multiplication e times

well consider what occurs in cryptographic secure communication:
a message such as "HI" represented as number a e.g. a=0708
and then need to calculate a^e (modulo another value m)
where e is a number such as the following:
692,469,504,614,203,622,460,465,868,734,959,711,852,932,318,
302,149,455,793,493,889,446,970,470,508,640,328,165,696,445,
236,740,914,740,354,470,714,166,287,934,901,598,998,105,531,
316,760,680,771,813
( $ man ssh-keygen )

the number of seconds required by a computer to do e multiplications would be at least the following:
692,469,504,614,203,622,460,465,868,734,959,711,852,932,318,
302,149,455,793,493,889,446,970,470,508,640,328,165,696,445,
236,740,914,740,354,470,714,166,287,934,901,598,998,105,531,
316,760 s.
in years that's more than the following:
692,469,504,614,203,622,460,465,868,734,959,711,852,932,318,
302,149,455,793,493,889,446,970,470,508,640,328,165,696,445,
236,740,914,740,354,470,714,166,287,934,901,598,998,105 y.

instead of that,
repeated squaring algorithm faster way to calculate a^e
even with that value of e
loop (shown below) will repeat only times(!)
which requires only a fraction of a second

to understand this algorithm,
consider first a simple example:

suppose e is 8192
and suppose the following operations are performed:

  sqrrep := a;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²

at that point have a^e — doing only operations, not 8,192(!)

what if e is 139264 which is 131072 + 8192 ?

  result := 1;
  sqrrep := a;
    // now sqrrep is a¹ which is a^2⁰
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a² which is a^2¹
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a⁴ which is a^2²
  ·
  ·
  ·
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a⁸¹⁹² which is a^2¹³
  result := result * sqrrep;
    // now result is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  sqrrep := sqrrep * sqrrep;
    // now sqrrep is a which is a²
  result := result * sqrrep;

at the end here that last multiplication  result * sqrrep
is a⁸¹⁹² * a¹³¹⁰⁷² (which is a^2¹³ * a^2¹⁷ )
which equals a⁽⁾ (which is a⁽⁾)
by Law 1 of Exponents
which equals a¹³⁹²⁶⁴ i.e. a^e which was desired
(incidentally note that e=139264_ten == 100010000000000000_two
and the binary representation reflects that e is  1*2¹⁷ + 1*2¹³ )

the repeated squaring algorithm for calculating a^e generalizes from the preceding examples:
start  result at 1 and  sqrrep at a ;
repeatedly square  sqrrep so  sqrrep holds values of a raised to successive powers of two;
and include value of  sqrrep in  result if e contains the corresponding power of two.
here's Java encoding of this algorithm:

int exponentiation(int a, int e) {
    int result = 1;
    int sqrrep = a;
    while ( e > 0 ) {
        // e == |_e_given / 2ⁱ_|  and  sqrrep == a^2ⁱ
        if ( e % 2 == 1 )     // as above with binary representation
                                // this condition corresponds
                                // to e_given containing 2ⁱ
            result = result * sqrrep;    // so make |result| contain sqrrep == a^2ⁱ
        sqrrep = sqrrep * sqrrep;        // advance sqrrep to a^{2⁽ⁱ⁺¹⁾}
        e = e/2;              // advance e to |_e_given/2⁽ⁱ⁺¹⁾_|
        }
    return  result;
    }

as above when determining binary representation,
e % 2 == 1 holds iff e_given contains corresponding 2ⁱ ;
and (as indicated in examples for 8192 etc. above),
sqrrep is the corresponding a^2ⁱ

see sample processing actually in homework

incidentally, further for cryptography,
we may not care about full result so much as result mod another number m
in this case actually do mod m different times during the algorithm
as shown in our textbook by Rosen p.226 (Algorithm 5) and as follows:

int modular_exponentiation(int a, int e, int m) {
  int result = 1;
  int sqrrep = a ;
  while ( e > 0 ) { 
    if ( e % 2 == 1 )
      result = result * sqrrep ;
    sqrrep = sqrrep * sqrrep ;
    e = e/2;                // e :=  |_e/2_|
    }
  return  result;
  }

e.g. to calculate 708⁹¹ mod 10001
don't straightforwardly start 708⁹¹ (:= )
that would lose precision
(even if not with this relatively small example exponent 91,
consider more realistic large exponent indicated above)

int modular_exponentiation(
    int a, int e, int m     // a := , e := , m := 
    )
  {
  int result = 1;           // result := 
  int sqrrep = a % m;       // sqrrep :=   %   :=  
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
                            // result :=   *  % 
                            //        :=   % 
                            //        :=  
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
                            // result :=   *  % 
                            //        :=   % 
                            //        :=  
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
                            // result :=   *  % 
                            //        :=   % 
                            //        :=  
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
                            // result :=   *  % 
                            //        :=   % 
                            //        :=  
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 ) {         //  > 0  :=  
    if ( e % 2 == 1 )       //  % 2 == 1  :=   == 1  :=  
      result = result * sqrrep % m;
                            // result :=   *  % 
                            //        :=   % 
                            //        :=  
    sqrrep = sqrrep * sqrrep % m;
                            // sqrrep :=   *  % 
                            //        :=   % 
                            //        :=  
    e = e/2;                // e :=  |_/2_|  :=  |__|  :=  
    }
  while ( e > 0 )           //  > 0  :=  

  return  result;           // return 
  }

secure communication would transmit 2419 instead of 0708 ("HI")

but then what?
well, receiver would calculate (2419⁴⁶²⁷) mod 10001 :=

the receiver needs to know
stay tuned for explanation of that in approaching lecture-module