// ==================================================================
// Author: Jean-Michel Richer
// Date: 20 Aug 2016
// Purpose: Use of MPI::Reduce with function to integrate
// ==================================================================
#include <unistd.h>
#include <iostream>
#include <cstdlib>
#include <unistd.h> // for sleep
#include <sstream>
using namespace std;
#include "ezmpi.h"
using namespace ez::mpi;

/**
 * function to integrate f(x)
 */ 
double f(double x) {
	return x * x;
}
 
/**
 * integrate from
 * @param a lower bound
 * @param b upper bound
 * @param n number of steps
 */ 
double integrate(double a, double b, int n) {
	double dx = (b-a) / n;
	
	double sum = 0;
	for (int i=1; i<n; ++i) {
		sum += f(a + i * dx);
	}
	return sum * dx;
}

/**
 * run master and slaves
 */
void run(int argc, char *argv[]) {
	
	Process p(argc, argv); 
	
	
	// data to send
	double a = 1.0;
	double b = 3.0;
	int steps = 10000000;
	
	double x_range = (b - a) / p.max();
	int steps_range = steps / p.max();
	
	double local_a = a + p.id() * x_range;
	double local_b = local_a + x_range; 
	double local_result = integrate(local_a, local_b, steps_range);
	
	p << "integrate from " << local_a << " to " << local_b;
	p << " during " << steps_range << " steps" << endl;
	p << "local_result=" << local_result << endl;
	
	double final_result = 0;
	p.synchronize();
	
	p.reduce(local_result, final_result, MPI::SUM);
	
	// expected result should be (9 - 1/3) = 8.6666
	if (p.is_master()) {
		p << "final result=" << final_result << endl;
	}
	
	sleep(1);
	p.logs(cout);
	
}

/**
 * main function
 */
int main(int argc, char ** argv) {
 	
	// call a function that contains code for master and slave
	// in order to avoid problems of initialization and finalization
	run(argc, argv);
	
	
	exit(EXIT_SUCCESS);
}