SHARE
TWEET

v2

Senderman Nov 17th, 2019 74 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package com.senderman;
  2.  
  3. import java.math.BigDecimal;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.TimeUnit;
  7.  
  8. class Calculator {
  9.     int m, n;
  10.     BigDecimal result, result2;
  11.     private BigDecimal[] threadResults;
  12.     private double[][] matrix;
  13.  
  14.     void fill() {
  15.         result = BigDecimal.ONE;
  16.         result2 = BigDecimal.ONE;
  17.         threadResults = new BigDecimal[5];
  18.         matrix = new double[m + 1][n + 1];
  19.         for (int i = 1; i <= m; i++) {
  20.             for (int j = 1; j <= n; j++) {
  21.                 int q = 13;
  22.                 matrix[i][j] = (double) j + 1 / (double) q;
  23.             }
  24.         }
  25.     }
  26.  
  27.     long calc() {
  28.         long start = System.nanoTime();
  29.         for(int j = 1; j <=n; j++){
  30.             result = result.multiply(new BigDecimal(matrix[1][j]).pow(3));
  31.         }
  32.  
  33.         result = result.pow(m);
  34.         return System.nanoTime() - start;
  35.     }
  36.  
  37.     long calcParallel() throws InterruptedException {
  38.  
  39.         // Calculate multiplication of the row (every row in matrix is the same as others) using 4 threads
  40.         Runnable r1 = () -> {
  41.             int end = n / 4;
  42.             BigDecimal res = BigDecimal.ONE;
  43.             for (int j = 1; j <= end; j++) {
  44.                 res = res.multiply(new BigDecimal(matrix[1][j]).pow(3));
  45.             }
  46.             threadResults[0] = res;
  47.         };
  48.  
  49.         Runnable r2 = () -> {
  50.             int end = n / 2;
  51.             BigDecimal res = BigDecimal.ONE;
  52.             for (int j = n / 4 + 1; j <= end; j++) {
  53.                 res = res.multiply(new BigDecimal(matrix[1][j]).pow(3));
  54.             }
  55.             threadResults[1] = res;
  56.         };
  57.  
  58.         Runnable r3 = () -> {
  59.             int end = n / 2 + n / 4;
  60.             BigDecimal res = BigDecimal.ONE;
  61.             for (int j = n / 2 + 1; j <= end; j++) {
  62.                 res = res.multiply(new BigDecimal(matrix[1][j]).pow(3));
  63.             }
  64.             threadResults[2] = res;
  65.         };
  66.  
  67.         Runnable r4 = () -> {
  68.             BigDecimal res = BigDecimal.ONE;
  69.             for (int j = n / 2 + n / 4 + 1; j <= n; j++) {
  70.                 res = res.multiply(new BigDecimal(matrix[1][j]).pow(3));
  71.             }
  72.             threadResults[3] = res;
  73.         };
  74.  
  75.         long start = System.nanoTime();
  76.         ExecutorService calcExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  77.         calcExecutor.submit(r1);
  78.         calcExecutor.submit(r2);
  79.         calcExecutor.submit(r3);
  80.         calcExecutor.submit(r4);
  81.         calcExecutor.shutdown();
  82.         calcExecutor.awaitTermination(1000, TimeUnit.DAYS);
  83.  
  84.         // Now we calculate multiplication of every quarter
  85.         threadResults[4] = threadResults[0]
  86.                 .multiply(threadResults[1])
  87.                 .multiply(threadResults[2])
  88.                 .multiply(threadResults[3]);
  89.  
  90.  
  91.         // calc threadResults[4] ^ m using 4 threads
  92.         result2 = threadResults[4].pow(m);
  93.  
  94.         return System.nanoTime() - start;
  95.     }
  96.  
  97.     void print() {
  98.         for (int i = 1; i <= m; i++) {
  99.             for (int j = 1; j <= n; j++) {
  100.                 System.out.print(matrix[i][j] + " ");
  101.             }
  102.             System.out.println();
  103.         }
  104.     }
  105.  
  106.     static String getTime(long span) {
  107.         long nanosec = span;
  108.         long microsec = nanosec / 1000;
  109.         nanosec = span - microsec * 1000;
  110.         long millisec = microsec / 1000;
  111.         microsec -= millisec * 1000;
  112.         long seconds = millisec / 1000;
  113.         millisec = millisec - seconds * 1000;
  114.         long mins = seconds / 60;
  115.         seconds -= mins * 60;
  116.         long hours = mins / 60;
  117.         mins -= hours * 60;
  118.         return String.format("%d часа, %d минут, %d секунд, %d миллисекунд, %d микросекунд и %d наносекунд",
  119.                 hours, mins, seconds, millisec, microsec, nanosec);
  120.     }
  121.  
  122.     static String getTime(long start, long end) {
  123.         return getTime(end - start);
  124.     }
  125. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top