Question

我有一个任务是写一个计算pi的并行程序（Chudnovsky公式）。但是，它在计算中具有因子性。因此，对于任务的分解，我想在开始计算公式之前计算阶乘（即，计算所有阶乘，将它们存储在某处，然后在需要读取它们时读取它们，而不是计算那些因子点）。

我在这里读过几个问题，但它们是关于单个因子数的并行计算。当我需要计算所有数字直到给定的索引（它们基于并行求和/乘积方法）时，它们不是非常有用。有没有人想要好好分解任务？

Answer 1

为此，您可以应用动态programmig。动态编程是一种以最有效的方式解决问题的方法。它实际上是避免一次又一次地计算子问题。对于阶乘n，你总是将n乘以（n-1）！如果你应用这个，我认为计算所有阶乘的更快的方法是串行：

<?php

include("incWageFunctions.php");

$hourlyWage = 12.75;
$hoursWorked = 45;
$wage = getWage($hoursWorked, $hourlyWage);

print("<p>Your hourly wage is $$hourlyWage and you worked
        $hoursWorked hours.</p>");
print("<p>Your wages are $$wage.</p>");
?>

Answer 2

您可以在此处使用fork并加入并行策略。我们假设您必须计算10的阶乘。为此，您必须将数字乘以2到10.您可以将此任务分开，直到您的任务变为2或3个数字的乘法。

以下是此示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkTest {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool(4);
        for (int i = 2; i < 11; i++) {
            Factorial myRecursiveAction = new Factorial(2, i);
            forkJoinPool.invoke(myRecursiveAction);
            System.out.println("i=" + i + " result=" + myRecursiveAction.getRawResult());

        }
    }
}

class Factorial extends RecursiveTask<Long> {
    private int low;
    private int high;

    public Factorial(int low, int high) {
        this.low = low;
        this.high = high;
    }

    protected Long compute() {
        if (high - low >= 2) {
            //System.out.println("Dividing number from : " + low + " - " + high);
            int mid = (high + low) / 2;
            Factorial lowerRange = new Factorial(low, mid);
            Factorial higherRange = new Factorial(mid + 1, high);
            List<Factorial> subtasks = new ArrayList<Factorial>();
            subtasks.add(lowerRange);
            subtasks.add(higherRange);

            for (Factorial subtask : subtasks) {
                subtask.fork();
            }

            long result = 1;
            for (Factorial subtask : subtasks) {
                result *= subtask.join();
            }
            return result;

        } else {
            long facto = low;
            for (int i = low + 1; i <= high; i++) {
                facto = facto * i;
            }
            //System.out.println("Multiplying number from : " + low + " - " + high + " result=" + facto);
            return facto;
        }
    }

}

直到给定数量的所有元素的并行因子计算

2 个答案: