Advertisement
Guest User

Java Number and Integer Performance Test

a guest
Jun 17th, 2019
144
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 8.93 KB | None | 0 0
  1. import java.util.Date;
  2.  
  3. class IntegerOperationTest
  4. {
  5.     public static final int ITERATION_COUNT = 500000000;
  6.  
  7.     public static void main(String[] args)
  8.     {
  9.         runPureAddIntTest();
  10.         runPureSubtractIntTest();
  11.        
  12.         runPureFloatAddTest();
  13.         runPureSubstractFloatTest();
  14.  
  15.         runPureIntPowerTest();
  16.         runPurePowerFloatTest();
  17.  
  18.         runPureDivisionFloatTest();
  19.  
  20.         runAddIntTest();
  21.         runSubstractIntTest();
  22.         runFloatAddTest();
  23.         runSubstractFloatTest();
  24.         runIntPowerTest();
  25.         runFloatPowerTest();
  26.         runIntModuloTest();
  27.         runFloatModuloTest();
  28.     }
  29.  
  30.     public static void runPureAddIntTest()
  31.     {
  32.         int i = 0;
  33.         int a = 0;
  34.         int b = 0;
  35.         int c = 0;
  36.         int d = 0;
  37.         int f = 0;
  38.  
  39.         long time = new Date().getTime();
  40.  
  41.         for(i = 0; i <= ITERATION_COUNT; i++)
  42.         {
  43.             a++;
  44.             b++;
  45.             c++;
  46.             d++;
  47.             f++;
  48.         }
  49.  
  50.         System.out.println("Pure addition int test complete in: " + (new Date().getTime() - time));
  51.     }
  52.  
  53.     public static void runPureSubtractIntTest()
  54.     {
  55.         int i = 0;
  56.         int a = Integer.MAX_VALUE;
  57.         int b = Integer.MAX_VALUE;
  58.         int c = Integer.MAX_VALUE;
  59.         int d = Integer.MAX_VALUE;
  60.         int f = Integer.MAX_VALUE;
  61.  
  62.         long time = new Date().getTime();
  63.  
  64.         for(i = ITERATION_COUNT; i > 0; i--)
  65.         {
  66.             a--;
  67.             b--;
  68.             c--;
  69.             d--;
  70.             f--;
  71.         }
  72.  
  73.         System.out.println("Pure subtract int test complete in: " + (new Date().getTime() - time));
  74.     }
  75.  
  76.      public static void runPureFloatAddTest()
  77.     {
  78.         int i = 0;
  79.         float a = 0;
  80.         float b = 0;
  81.         float c = 0;
  82.         float d = 0;
  83.         float f = 0;
  84.  
  85.         float increment1 = 0.1f;
  86.         float increment2 = 0.2f;
  87.         float increment3 = 0.3f;
  88.         float increment4 = 0.4f;
  89.         float increment5 = 0.5f;
  90.  
  91.  
  92.         long time = new Date().getTime();
  93.  
  94.         for(i = 0; i <= ITERATION_COUNT; i++)
  95.         {
  96.             a += increment1;
  97.             b += increment2;
  98.             c += increment3;
  99.             d += increment4;
  100.             f += increment5;
  101.         }
  102.  
  103.         System.out.println("Pure addition float test complete in: " + (new Date().getTime() - time));
  104.     }
  105.  
  106.     public static void runPureSubstractFloatTest()
  107.     {
  108.         int i = 0;
  109.         float a = 0;
  110.         float b = 0;
  111.         float c = 0;
  112.         float d = 0;
  113.         float f = 0;
  114.  
  115.         float increment1 = 0.1f;
  116.         float increment2 = 0.2f;
  117.         float increment3 = 0.3f;
  118.         float increment4 = 0.4f;
  119.         float increment5 = 0.5f;
  120.  
  121.         long time = new Date().getTime();
  122.  
  123.         for(i = ITERATION_COUNT; i > 0; i--)
  124.         {
  125.             a -= increment1;
  126.             b -= increment2;
  127.             c -= increment3;
  128.             d -= increment4;
  129.             f -= increment5;
  130.         }
  131.  
  132.         System.out.println("Pure subtract float test complete in: " + (new Date().getTime() - time));
  133.     }
  134.  
  135.     public static void runPureIntPowerTest()
  136.     {
  137.         int i = 0;
  138.         int a = 0;
  139.         int b = 0;
  140.         int c = 0;
  141.         int d = 0;
  142.         int f = 0;
  143.  
  144.         long time = new Date().getTime();
  145.  
  146.         for(i = 0; i <= ITERATION_COUNT; i++)
  147.         {
  148.             a *= 2;
  149.             b *= 2;
  150.             c *= 2;
  151.             d *= 2;
  152.             f *= 2;
  153.         }
  154.  
  155.         System.out.println("Pure power int test complete in: " + (new Date().getTime() - time));
  156.     }
  157.    
  158.     public static void runPurePowerFloatTest()
  159.     {
  160.         int i = 0;
  161.         float a = 0;
  162.         float b = 0;
  163.         float c = 0;
  164.         float d = 0;
  165.         float f = 0;
  166.  
  167.         float increment1 = 0.1f;
  168.         float increment2 = 0.2f;
  169.         float increment3 = 0.3f;
  170.         float increment4 = 0.4f;
  171.         float increment5 = 0.5f;
  172.  
  173.         long time = new Date().getTime();
  174.  
  175.         for(i = 0; i <= ITERATION_COUNT; i++)
  176.         {
  177.             a *= increment1;
  178.             b *= increment2;
  179.             c *= increment3;
  180.             d *= increment4;
  181.             f *= increment5;
  182.         }
  183.  
  184.         System.out.println("Pure power float test complete in: " + (new Date().getTime() - time));
  185.     }
  186.  
  187.     public static void runPureDivisionFloatTest()
  188.     {
  189.         int i = 0;
  190.         float a = Float.MAX_VALUE;
  191.         float b = Float.MAX_VALUE;
  192.         float c = Float.MAX_VALUE;
  193.         float d = Float.MAX_VALUE;
  194.         float f = Float.MAX_VALUE;
  195.  
  196.         float div1 = 1.0001f;
  197.         float div2 = 1.0002f;
  198.         float div3 = 1.0003f;
  199.         float div4 = 1.0004f;
  200.         float div5 = 1.0005f;
  201.  
  202.         long time = new Date().getTime();
  203.  
  204.         for(i = 0; i <= ITERATION_COUNT; i++)
  205.         {
  206.             a /= div1;
  207.             b /= div2;
  208.             c /= div3;
  209.             d /= div4;
  210.             f /= div5;
  211.         }
  212.  
  213.         System.out.println("Pure division float test complete in: " + (new Date().getTime() - time));
  214.     }
  215.  
  216.     public static void runAddIntTest()
  217.     {
  218.         int i = 0;
  219.         int c = 0;
  220.         int m = 0;
  221.         int f = 0;
  222.  
  223.         long time = new Date().getTime();
  224.  
  225.         for(i = 0; i <= ITERATION_COUNT; i++)
  226.         {
  227.             if(c % 2 == 0)
  228.             {
  229.                 c++;
  230.                 f += c;
  231.             }
  232.             else
  233.             {
  234.                 c += 2;
  235.                 f += c;
  236.             }
  237.  
  238.             if(m % 2 == 0)
  239.             {
  240.                 m++;
  241.                 f += m;
  242.             }
  243.             else
  244.             {
  245.                 m += 2;
  246.                 f += m;
  247.             }
  248.         }
  249.  
  250.         System.out.println("Addition int test complete in: " + (new Date().getTime() - time));
  251.     }
  252.  
  253.     public static void runSubstractIntTest()
  254.     {
  255.         int i = 0;
  256.         int c1 = 1;
  257.         int c2 = 2;
  258.  
  259.         int d = Integer.MAX_VALUE;
  260.         int m = Integer.MAX_VALUE;
  261.         int f = Integer.MAX_VALUE;
  262.  
  263.         long time = new Date().getTime();
  264.  
  265.         for(i = 0; i <= ITERATION_COUNT; i++)
  266.         {
  267.             if(d % 2 == 0)
  268.             {
  269.                 d--;
  270.                 f -= c1;
  271.             }
  272.             else
  273.             {
  274.                 d -= c2;
  275.                 f -= c2;
  276.             }
  277.  
  278.             if(m % 2 == 0)
  279.             {
  280.                 m--;
  281.                 f -= c1;
  282.             }
  283.             else
  284.             {
  285.                 m -= c2;
  286.                 f -= c2;
  287.             }
  288.         }
  289.  
  290.         System.out.println("Subtract int test complete in: " + (new Date().getTime() - time));
  291.     }
  292.  
  293.     public static void runFloatAddTest()
  294.     {
  295.         int i = 0;
  296.         float c = 0;
  297.         float m = 0;
  298.         float f = 0;
  299.  
  300.         long time = new Date().getTime();
  301.  
  302.         for(i = 0; i <= ITERATION_COUNT; i++)
  303.         {
  304.             if(i % 2 == 0)
  305.             {
  306.                 c++;
  307.                 f += c;
  308.             }
  309.             else
  310.             {
  311.                 c += 2;
  312.                 f += c;
  313.             }
  314.  
  315.             if(i % 2 == 0)
  316.             {
  317.                 m++;
  318.                 f += m;
  319.             }
  320.             else
  321.             {
  322.                 m += 2;
  323.                 f += m;
  324.             }
  325.         }
  326.  
  327.         System.out.println("Addition float test complete in: " + (new Date().getTime() - time));
  328.     }
  329.  
  330.     public static void runSubstractFloatTest()
  331.     {
  332.         int i = 0;
  333.  
  334.         float c1 = 1.1f;
  335.         float c2 = 2.2f;
  336.  
  337.         float d = Float.MAX_VALUE;
  338.         float m = Float.MAX_VALUE;
  339.         float f = Float.MAX_VALUE;
  340.  
  341.         long time = new Date().getTime();
  342.  
  343.         for(i = 0; i <= ITERATION_COUNT; i++)
  344.         {
  345.             if(i % 2 == 0)
  346.             {
  347.                 d--;
  348.                 f -= c1;
  349.             }
  350.             else
  351.             {
  352.                 d -= c2;
  353.                 f -= c2;
  354.             }
  355.  
  356.             if(i % 2 == 0)
  357.             {
  358.                 d--;
  359.                 f -= c1;
  360.             }
  361.             else
  362.             {
  363.                 d -= c2;
  364.                 f -= c2;
  365.             }
  366.         }
  367.  
  368.         System.out.println("Subtract float test complete in: " + (new Date().getTime() - time));
  369.     }
  370.  
  371.     public static void runIntPowerTest()
  372.     {
  373.         int i = 0;
  374.        
  375.         int c = 0;
  376.  
  377.         int c1 = 2;
  378.         int c2 = 3;
  379.  
  380.         int m = 0;
  381.         int f = 0;
  382.  
  383.         long time = new Date().getTime();
  384.  
  385.         for(i = 0; i <= ITERATION_COUNT; i++)
  386.         {
  387.             if(c % 2 == 0)
  388.             {
  389.                 c *= c1;
  390.                 f *= c;
  391.             }
  392.             else
  393.             {
  394.                 c *= c2;
  395.                 f *= c;
  396.             }
  397.  
  398.             if(m % 2 == 0)
  399.             {
  400.                 m *= c1;
  401.                 f += m;
  402.             }
  403.             else
  404.             {
  405.                 m += c2;
  406.                 f += m;
  407.             }
  408.         }
  409.  
  410.         System.out.println("Power int test complete in: " + (new Date().getTime() - time));
  411.     }
  412.  
  413.     public static void runFloatPowerTest()
  414.     {
  415.         int i = 0;
  416.        
  417.         float c = 0;
  418.  
  419.         float c1 = 1.5f;
  420.         float c2 = 1.9f;
  421.  
  422.         float m = 0;
  423.         float f = 0;
  424.  
  425.         long time = new Date().getTime();
  426.  
  427.         for(i = 0; i <= ITERATION_COUNT; i++)
  428.         {
  429.             if(i % 2 == 0)
  430.             {
  431.                 c *= c1;
  432.                 f *= c;
  433.             }
  434.             else
  435.             {
  436.                 c *= c2;
  437.                 f *= c;
  438.             }
  439.  
  440.             if(i % 2 == 0)
  441.             {
  442.                 m *= c1;
  443.                 f += m;
  444.             }
  445.             else
  446.             {
  447.                 m += c2;
  448.                 f += m;
  449.             }
  450.         }
  451.  
  452.         System.out.println("Power float test complete in: " + (new Date().getTime() - time));
  453.     }
  454.  
  455.     public static void runIntModuloTest()
  456.     {
  457.         int i = 0;
  458.        
  459.         int c = 2;
  460.  
  461.         int c1 = 2;
  462.         int c2 = 3;
  463.  
  464.         int m = 4;
  465.         int f = 8;
  466.  
  467.         boolean hasRemainder;
  468.  
  469.         long time = new Date().getTime();
  470.  
  471.         for(i = 0; i <= ITERATION_COUNT; i++)
  472.         {
  473.             if(i % 2 == 0)
  474.             {
  475.                 hasRemainder = c % c1 == 0;
  476.                 hasRemainder = f % c == 0;
  477.             }
  478.             else
  479.             {
  480.                 hasRemainder = c % c2 == 0;
  481.                 hasRemainder = f % c == 0;
  482.             }
  483.  
  484.             if(i % 2 == 0)
  485.             {
  486.                 hasRemainder = m % c1 == 0;
  487.                 hasRemainder = f % m == 0;
  488.             }
  489.             else
  490.             {
  491.                 hasRemainder = m % c2 == 0;
  492.                 hasRemainder = f % m == 0;
  493.             }
  494.         }
  495.  
  496.         System.out.println("Modulo int test complete in: " + (new Date().getTime() - time));
  497.     }
  498.  
  499.     public static void runFloatModuloTest()
  500.     {
  501.         int i = 0;
  502.        
  503.         float c = 2.0f;
  504.  
  505.         float c1 = 1.5f;
  506.         float c2 = 1.9f;
  507.  
  508.         float m = 4.0f;
  509.         float f = 8.0f;
  510.  
  511.         boolean hasRemainder;
  512.  
  513.         long time = new Date().getTime();
  514.  
  515.         for(i = 0; i <= ITERATION_COUNT; i++)
  516.         {
  517.             if(i % 2 == 0)
  518.             {
  519.                 hasRemainder = c % c1 == 0.0f;
  520.                 hasRemainder = f % c == 0.0f;
  521.             }
  522.             else
  523.             {
  524.                 hasRemainder = c % c2 == 0.0f;
  525.                 hasRemainder = f % c == 0.0f;
  526.             }
  527.  
  528.             if(i % 2 == 0)
  529.             {
  530.                 hasRemainder = m % c1 == 0.0f;
  531.                 hasRemainder = f % m == 0.0f;
  532.             }
  533.             else
  534.             {
  535.                 hasRemainder = m % c2 == 0.0f;
  536.                 hasRemainder = f % m == 0.0f;
  537.             }
  538.         }
  539.  
  540.         System.out.println("Modulo float test complete in: " + (new Date().getTime() - time));
  541.     }
  542. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement