home *** CD-ROM | disk | FTP | other *** search
/ ActiveX Programming Unleashed CD / AXU.iso / jgl_1_1 / jgl_1_1.exe / benchmarks / ArrayBenchmarks.java next >
Encoding:
Java Source  |  1996-07-15  |  6.8 KB  |  232 lines
  1. import jgl.*;
  2. import java.util.Vector;
  3. import java.util.Enumeration;
  4.  
  5. public class ArrayBenchmarks
  6.   {
  7.   static Randomizer random = new Randomizer();
  8.   static final int LOOPS = 400;
  9.   static final int MAX_SIZE = 1000;
  10.  
  11.   public static void main( String args[] )
  12.     {
  13.     System.out.println( "ArrayBenchmarks" );
  14.     arrayGetting();
  15.     arrayPutting();
  16.     arrayIterating();
  17.     arrayAdding();
  18.     arrayClearing();
  19.     arrayInserting();
  20.     arrayRemoving();
  21.     }
  22.  
  23.   static Object[] getRandomArrayInts()
  24.     {
  25.     int size = Randomizer.getInt( MAX_SIZE );
  26.     Integer[] ints = new Integer[ size ];
  27.     for( int i = 0; i < size; i++ )
  28.       ints[ i ] = new Integer( Randomizer.getInt( 100 ) );
  29.     return ints;
  30.     }
  31.  
  32.   static void arrayAdding()
  33.     {
  34.     Benchmark jglBenchmark = new Benchmark( "jglArrayAdding", 100 );
  35.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorAdding", 100 );
  36.  
  37.     for( int i = 0; i <= LOOPS; i++ )
  38.       {
  39.       Object[] data = getRandomArrayInts();
  40.       jgl.Array jglArray = new jgl.Array();
  41.       java.util.Vector jdkVector = new java.util.Vector(); 
  42.  
  43.       jdkBenchmark.start();
  44.       for( int j = 0; j < data.length; j++ )
  45.         jdkVector.addElement( data[ j ] );
  46.       jdkBenchmark.stop();
  47.  
  48.       jglBenchmark.start();
  49.       for( int j = 0; j < data.length; j++ )
  50.         jglArray.add( data[ j ] );
  51.       jglBenchmark.stop();
  52.       }
  53.  
  54.     jglBenchmark.compareTo( jdkBenchmark );
  55.     }
  56.  
  57.   static void arrayGetting()
  58.     {
  59.     Benchmark jglBenchmark = new Benchmark( "jglArrayGetting", 100 );
  60.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorGetting", 100 );
  61.  
  62.     for( int i = 0; i <= LOOPS; i++ )
  63.       {
  64.       Object[] data = getRandomArrayInts();
  65.       jgl.Array jglArray = new jgl.Array( data );
  66.       java.util.Vector jdkVector = new java.util.Vector(); 
  67.       for( int j = 0; j < data.length; j++ )
  68.         jdkVector.addElement( data[ j ] );
  69.       Object object = null;
  70.  
  71.       jdkBenchmark.start();
  72.       for( int j = 0; j < data.length; j++ )
  73.         object = jdkVector.elementAt( j );
  74.       jdkBenchmark.stop();
  75.  
  76.       jglBenchmark.start();
  77.       for( int j = 0; j < data.length; j++ )
  78.         object = jglArray.at( j );
  79.       jglBenchmark.stop();
  80.       }
  81.  
  82.     jglBenchmark.compareTo( jdkBenchmark );
  83.     }
  84.  
  85.   static void arrayPutting()
  86.     {
  87.     Benchmark jglBenchmark = new Benchmark( "jglArrayPutting", 100 );
  88.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorPutting", 100 );
  89.  
  90.     for( int i = 0; i <= LOOPS; i++ )
  91.       {
  92.       Object[] data = getRandomArrayInts();
  93.       jgl.Array jglArray = new jgl.Array( data );
  94.       java.util.Vector jdkVector = new java.util.Vector(); 
  95.       for( int j = 0; j < data.length; j++ )
  96.         jdkVector.addElement( data[ j ] );
  97.       Object object = null;
  98.       Integer zero = new Integer( 0 );
  99.  
  100.       jdkBenchmark.start();
  101.       for( int j = 0; j < data.length; j++ )
  102.         jdkVector.setElementAt( zero, j );
  103.       jdkBenchmark.stop();
  104.  
  105.       jglBenchmark.start();
  106.       for( int j = 0; j < data.length; j++ )
  107.         jglArray.put( j, zero );
  108.       jglBenchmark.stop();
  109.       }
  110.  
  111.     jglBenchmark.compareTo( jdkBenchmark );
  112.     }
  113.  
  114.   static void arrayInserting()
  115.     {
  116.     Benchmark jglBenchmark = new Benchmark( "jglArrayInserting", 100 );
  117.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorInserting", 100 );
  118.  
  119.     for( int i = 0; i <= LOOPS; i++ )
  120.       {
  121.       Object[] data = getRandomArrayInts();
  122.       jgl.Array jglArray = new jgl.Array( data );
  123.       java.util.Vector jdkVector = new java.util.Vector(); 
  124.       int intdata[] = new int[ data.length ];
  125.       for( int j = 0; j < data.length; j++ )
  126.         {
  127.         jdkVector.addElement( data[ j ] );
  128.         intdata[ j ] = ((Integer) data[ j ]).intValue() % data.length;
  129.         }
  130.       Integer zero = new Integer( 0 );
  131.  
  132.       jglBenchmark.start();
  133.       for( int j = 0; j < data.length; j++ )
  134.         jglArray.insert( intdata[ j ], zero );
  135.       jglBenchmark.stop();
  136.  
  137.       jdkBenchmark.start();
  138.       for( int j = 0; j < data.length; j++ )
  139.         jdkVector.insertElementAt( zero, j );
  140.       jdkBenchmark.stop();
  141.       }
  142.  
  143.     jglBenchmark.compareTo( jdkBenchmark );
  144.     }
  145.  
  146.   static void arrayRemoving()
  147.     {
  148.     Benchmark jglBenchmark = new Benchmark( "jglArrayRemoving", 100 );
  149.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorRemoving", 100 );
  150.  
  151.     for( int i = 0; i <= LOOPS; i++ )
  152.       {
  153.       Object[] data = getRandomArrayInts();
  154.       jgl.Array jglArray = new jgl.Array( data );
  155.       java.util.Vector jdkVector = new java.util.Vector(); 
  156.       for( int j = 0; j < data.length; j++ )
  157.         jdkVector.addElement( data[ j ] );
  158.  
  159.       int intdata[] = new int[ data.length ];
  160.  
  161.       for( int j = 0; j < data.length; j++ )
  162.         intdata[ j ] = random.getInt( 0, data.length - j - 1 );
  163.  
  164.       jglBenchmark.start();
  165.       for( int j = 0; j < data.length; j++ )
  166.         jglArray.remove( intdata[ j ] );
  167.       jglBenchmark.stop();
  168.  
  169.       jdkBenchmark.start();
  170.       for( int j = 0; j < data.length; j++ )
  171.         jdkVector.removeElementAt( intdata[ j ] );
  172.       jdkBenchmark.stop();
  173.       }
  174.  
  175.     jglBenchmark.compareTo( jdkBenchmark );
  176.     }
  177.  
  178.   static void arrayIterating()
  179.     {
  180.     Benchmark jglBenchmark = new Benchmark( "jglArrayIterating", 100 );
  181.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorIterating", 100 );
  182.  
  183.     for( int i = 0; i <= LOOPS; i++ )
  184.       {
  185.       Object[] data = getRandomArrayInts();
  186.       jgl.Array jglArray = new jgl.Array( data );
  187.       java.util.Vector jdkVector = new java.util.Vector(); 
  188.       for( int j = 0; j < data.length; j++ )
  189.         jdkVector.addElement( data[ j ] );
  190.       Object object = null;
  191.  
  192.       jdkBenchmark.start();
  193.       Enumeration jdkEnumerator = jdkVector.elements();
  194.       while( jdkEnumerator.hasMoreElements() )
  195.         jdkEnumerator.nextElement();
  196.       jdkBenchmark.stop();
  197.  
  198.       jglBenchmark.start();
  199.       Enumeration jglEnumerator = jglArray.elements();
  200.       while( jglEnumerator.hasMoreElements() )
  201.         jglEnumerator.nextElement();
  202.       jglBenchmark.stop();
  203.       }
  204.  
  205.     jglBenchmark.compareTo( jdkBenchmark );
  206.     }
  207.  
  208.   static void arrayClearing()
  209.     {
  210.     Benchmark jglBenchmark = new Benchmark( "jglArrayClearing", 100 );
  211.     Benchmark jdkBenchmark = new Benchmark( "jdkVectorClearing", 100 );
  212.  
  213.     for( int i = 0; i <= LOOPS; i++ )
  214.       {
  215.       Object[] data = getRandomArrayInts();
  216.       jgl.Array jglArray = new jgl.Array( data );
  217.       java.util.Vector jdkVector = new java.util.Vector(); 
  218.       for( int j = 0; j < data.length; j++ )
  219.         jdkVector.addElement( data[ j ] );
  220.  
  221.       jdkBenchmark.start();
  222.       jdkVector.removeAllElements();
  223.       jdkBenchmark.stop();
  224.  
  225.       jglBenchmark.start();
  226.       jglArray.clear();
  227.       jglBenchmark.stop();
  228.       }
  229.  
  230.     jglBenchmark.compareTo( jdkBenchmark );
  231.     }
  232.   }