Hadoop计算圆周率

Hadoop计算圆周率的方法有多种，以下是两种常见的方法：

1. 使用Hadoop自带的pi示例程序：

hadoop jar /usr/local/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-*.jar pi <numMaps> <numSamples>

其中，`<numMaps>`表示使用的Map任务数，`<numSamples>`表示采样点的总数。该程序会在Hadoop集群上运行，并输出计算得到的圆周率的近似值。

2. 自定义MapReduce程序：
你可以编写自己的MapReduce程序来计算圆周率。具体步骤如下：
- 编写一个Mapper类，将输入的数据进行处理，生成随机的坐标点。
- 编写一个Reducer类，统计在圆内的点的数量。
- 编写一个Driver类，设置Mapper和Reducer类，并配置输入输出路径等参数。
- 将程序打包成jar文件，并在Hadoop集群上运行。

这样，Hadoop会自动将任务分发给不同的节点进行并行计算，最后得到圆周率的近似值。

相关问题

hadoop实现串行化计算圆周率

串行化计算圆周率的方法是使用蒙特卡罗方法，即随机投点法。具体实现步骤如下：

1. 生成随机点：随机生成x、y坐标在0到1之间的点，共生成N个点。

2. 判断点是否在圆内：判断这N个点是否在以(0.5,0.5)为圆心，半径为0.5的圆内，如果在圆内，则计数器加1。

3. 计算圆周率：根据蒙特卡罗算法的原理，圆内点数与总点数的比例趋近于圆的面积与正方形面积的比例，即π/4。因此，根据计数器的值可以计算出π的近似值。

下面是一个使用Hadoop实现串行化计算圆周率的例子：

1. 创建输入文件input.txt，每行一个点，格式为"x,y"。

0.1,0.2
0.3,0.4
0.5,0.6
...

2. 编写MapReduce程序。

Mapper阶段：读入每个点，判断是否在圆内，如果在圆内，则输出"1,0"，否则输出"0,1"。

Reducer阶段：将Mapper输出的结果累加，得到圆内点数和总点数，计算π的近似值。

代码如下：

Mapper:

public class PiMapper extends Mapper<LongWritable, Text, IntWritable, IntWritable> {
  private final static IntWritable one = new IntWritable(1);
  private final static IntWritable zero = new IntWritable(0);
  private final static double radius = 0.5;
  
  public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    String[] coordinates = value.toString().split(",");
    double x = Double.parseDouble(coordinates[0]);
    double y = Double.parseDouble(coordinates[1]);
    if (Math.sqrt((x-0.5)*(x-0.5) + (y-0.5)*(y-0.5)) < radius) {
      context.write(one, zero);
    } else {
      context.write(zero, one);
    }
  }
}

Reducer:

public class PiReducer extends Reducer<IntWritable, IntWritable, Text, NullWritable> {
  public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
    int inside = 0;
    int total = 0;
    for (IntWritable value : values) {
      inside += value.get();
      total += 1;
    }
    double pi = 4.0 * inside / total;
    context.write(new Text("Pi is roughly " + pi), NullWritable.get());
  }
}

3. 将程序打包成jar包并提交到Hadoop集群上运行。

hadoop jar pi.jar Pi input.txt output

4. 查看输出结果。

程序运行完毕后，在output目录下会生成一个名为part-r-00000的输出文件，其中包含了π的近似值。

参考资料：

[1] Hadoop MapReduce实现圆周率的计算. https://www.jianshu.com/p/ce8d80f0c1e0

[2] MapReduce计算圆周率. https://blog.csdn.net/guohongtao/article/details/19610591

请给出hadoop自带计算圆周率的代码及注释

下面是 Hadoop 自带的计算圆周率的示例代码及注释：

package org.apache.hadoop.examples;

import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Iterator;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;

public class PiEstimator {

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    JobConf job = new JobConf(conf, PiEstimator.class);
    job.setJobName("pi");

    job.setOutputKeyClass(NullWritable.class);
    job.setOutputValueClass(NullWritable.class);

    job.setMapperClass(Map.class);
    job.setReducerClass(Reduce.class);

    job.setInputFormat(TextInputFormat.class);
    job.setOutputFormat(TextOutputFormat.class);

    FileInputFormat.setInputPaths(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));

    JobClient.runJob(job);
  }

  public static class Map extends MapReduceBase
      implements Mapper<Object, Text, NullWritable, NullWritable> {

    private long numRecords = 0;

    public void map(Object key, Text value,
        OutputCollector<NullWritable, NullWritable> output, Reporter reporter)
        throws IOException {

      String line = value.toString();
      int numInside = 0;
      int numOutside = 0;

      // 对于输入数据中的每一行，将其解析为两个 double 值，代表一个点的 x 和 y 坐标
      // 然后计算该点是否在圆内，并将计数器加 1
      // 最后输出两个计数器的值，供 Reduce 函数聚合
      for (String token : line.split("\\p{Space}+")) {
        double x = Double.parseDouble(token);
        double y = Double.parseDouble(token);
        if (x * x + y * y <= 1) {
          numInside++;
        } else {
          numOutside++;
        }
        numRecords++;
      }

      // 输出计数器的值，供 Reduce 函数聚合
      output.collect(NullWritable.get(), NullWritable.get());
    }

    @Override
    public void close() throws IOException {
      // 输出计数器的值，供 Reduce 函数聚合
      FileSystem fileSys = FileSystem.get(getConf());
      fileSys.create(new Path("mypath/num_records"), true).writeLong(numRecords);
    }
  }

  public static class Reduce extends MapReduceBase
      implements Reducer<NullWritable, NullWritable, NullWritable, DoubleWritable> {

    public void reduce(NullWritable key, Iterator<NullWritable> values,
        OutputCollector<NullWritable, DoubleWritable> output, Reporter reporter)
        throws IOException {
      Configuration conf = new Configuration();
      FileSystem fileSys = FileSystem.get(conf);
      long numRecords = fileSys.open(new Path("mypath/num_records")).readLong();

      // 计算圆周率的估计值
      double pi = 4.0 * numRecords / PiEstimator.NUM_MAP_TASKS / PiEstimator.NUM_SAMPLES_PER_MAP_TASK;

      // 输出圆周率的估计值
      DecimalFormat df = new DecimalFormat("#.##########");
      output.collect(NullWritable.get(), new DoubleWritable(Double.parseDouble(df.format(pi))));
    }
  }
  
  private static final int NUM_MAP_TASKS = 20;
  private static final int NUM_SAMPLES_PER_MAP_TASK = 100000;
}

这个示例代码包括一个 Mapper 和一个 Reducer。Mapper 阶段会对输入数据中的每个点进行判断，看该点是否在圆内，然后输出计数器的值，供 Reducer 函数聚合。Reducer 阶段会读取 Mapper 输出的计数器值，计算圆周率的估计值，并输出。该示例代码使用了 Hadoop 的 MapReduce 框架和 HDFS 分布式文件系统，可以通过输入参数指定输入和输出路径。