View source for Java and Python multiply integers differently

--[[User:Thiebaut|D. Thiebaut]] ([[User talk:Thiebaut|talk]]) 09:21, 19 October 2015 (EDT)
----
=Mult2.java=
<br />
Below is a program in Java that accumulates ints in a variable, making the contents grow larger, until something unfortunate happens...
<br />
::<source lang="java">
/*
  Mult2.java
  keep accumulating some number in an integer, and
  see what happens when it gets to some large value...

  To compile and run:

  javac Mult2.java
  java Mult2
 */

class Mult2 {
    public static void main( String[] args ) {

        int a = 1;
        System.out.println( "a = " + a );

        for ( int i=0; i<70; i++ ) {
            a = a*2;
            System.out.println( "a = " + a );
        }

    }
}

</source>
<br />
; Exercise
: Change the int (32 bits) to a long (64 bits).   How does the output change?   Still the same problem?
<br />
=Mult2.py=
<br />
Below is the same program in Python:
<br />
::<source lang="python">
# Mult2.py
# Demonstrate how Python reacts to integers that
# increase in size.

a = 1

for i in range( 70 ):
    a = a*2
    print( "a = ", a )

</source>
<br />
=Mult3.java=
<br />
Below is a program showing how to avoid the "bug" resulting from an integer overflow.
<br />
::<source lang="java">
# Mult3.java
# D. Thiebaut
# Example of overflow in an int, and how to use the BigInteger library.

public class Mult3 {

        public static void main(String[] args) {
            int x = 1;
            BigInteger xx = BigInteger.valueOf( x );
            BigInteger big2 = BigInteger.valueOf( 2 );

            for (int i=0; i<70; i++ ) {
                // -----------------------------------------------
                // a multiplication of ints
                x = x * 2;

                System.out.println( "x  = " + x  );
                
                // -----------------------------------------------
                // a multiplication of BigIntegers
                xx = xx.multiply( big2 );

                System.out.println( "xx = " + xx );
            }
        }
}
</source>
<br />
<br />
=Mulby2.cpp=
<br />
Below is a C++ program afflicted with the same limitation:
<br />
::<source lang="cpp">
// mulby2.cpp 
// D. Thiebaut
// C++ program illustrating limitation of ints,
// and possible overflow that goes undetected 
// by the program.
// 
// To compile and run:
//  g++ mulby2.cpp -o mulby2
//  ./mulby2

#include <iostream>

using namespace std;

int main() {
    //unsigned int x = 1;
    int x = 1;
    
    for ( int i=0; i<70; i++ ) {
        cout <<  x << endl;
        // cout << x << endl;
        x = x * 2;
    }
    
    cout << x << endl << endl;
    return 0;
}
</source>
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
[[Category:CSC231]][[Category:Nasm]][[Category:Java]][[Category:Python]]