The Big Programming Thread - Page 565

#!/bin/sh
order=$1

/usr/bin/gnuplot -p << EOF
set terminal png size 640 480
set term png font "OpenSans-Regular,8"
set obj 1 rectangle behind from screen 0,0 to screen 1,1
set obj 1 fillstyle solid 1.0 fillcolor rgbcolor "white"
set title "${order} maclaurin series of cosine with rational approxmation to pi"
set output 'cosine${order}.png'
plot 'cosine${order}.dat' using 1:2 with linespoints lc rgbcolor "black"
set title "${order} maclaurin series of sine with rational approxmation to pi"
set output 'sine${order}.png'
plot 'sine${order}.dat' using 1:2 with linespoints lc rgbcolor "black"
EOF

#include<algorithm>
#include<iostream>
#include<iterator>
#include<fstream>
#include<numeric>
#include<string>
#include<utility>
#include<vector>

template<class value_type>
value_type
	power(value_type argument,unsigned int exponent)
{ return (exponent==0)?1:argument*power(argument,exponent-1); }

namespace maclaurin{namespace guts{

struct sine{};
struct cosine{};

//generate {beta_0, ..., beta_N}, done in reverse since beta_i-1 = beta_i * beta_pi
template<class value_type>
std::vector<value_type>
	make_beta_sequence(value_type beta,unsigned int order)
{
	std::vector<value_type> beta_sequence(order+1);
	value_type variable{1};
	std::generate(
		beta_sequence.rbegin(),
		beta_sequence.rend(),
		[&]{
			auto tmp=variable;
			variable*=(beta*beta);
			return tmp; 
		}
	);
	return beta_sequence;
}

constexpr unsigned int index_delta{2};

//only difference twixt sine and cosine coefficients for the 
//pi seuuence is the last index. last because we are generating 
//them in reverse...

template<class tag>
constexpr unsigned int
	last_index(unsigned int);

template<>
constexpr unsigned int
	last_index<sine>(unsigned int order)
{ return index_delta*order+1; }

template<>
constexpr unsigned int
	last_index<cosine>(unsigned int order)
{ return index_delta*order; }

//generate product sequence {product_0, ..., product_t}, done in reverse 
template<class tag,class value_type>
std::vector<value_type>
	make_pi_sequence(unsigned int order)
{
	std::vector<value_type> pi_sequence(order+1);
	
	unsigned int index{last_index<tag>(order)};
	value_type variable{1};
	std::generate(
		pi_sequence.rbegin(),
		pi_sequence.rend(),
		[&]{
			auto tmp=variable;
			for(unsigned int iterator=0;iterator<index_delta;++iterator,--index)
				variable*=index;
			return tmp;
		}
	);
	return pi_sequence;
}

//generate coefficient sequence
//coefficient_i = (-1)^i * beta_i * pi_i
template<class tag,class value_type>
std::vector<value_type>
	make_coefficient_sequence(value_type beta,unsigned int order)
{
	auto beta_sequence{make_beta_sequence(beta,order)};
	auto pi_sequence{make_pi_sequence<tag,value_type>(order)};
	short sign{-1};
	
	auto& coefficient_sequence{beta_sequence}; //generate sequence in place
	std::transform(
		std::begin(pi_sequence),
		std::end(pi_sequence),
		std::begin(beta_sequence),
		std::begin(coefficient_sequence),
		[&](auto pi_i,auto beta_i){
			sign*=-1;
			return sign*pi_i*beta_i;
		}
	);

	return coefficient_sequence;
}

}

//function aliases for make_coefficient_sequence with sine and cosine tags
template<class value_type> 
constexpr auto sine=guts::make_coefficient_sequence<guts::sine,value_type>;

template<class value_type> 
constexpr auto cosine=guts::make_coefficient_sequence<guts::cosine,value_type>;

}

int 
	main()
{ 
	using namespace std;
	unsigned int order;
	long alpha;
	long beta;
	cout<<"enter pi fraction numerator: ";
	cin>>alpha;
	cout<<"enter pi fraction denominator: ";
	cin>>beta;

	unsigned int resolution{256};

	vector<double> coordinates(resolution+1);
	
	{
		unsigned int iterator{0};
		generate(
			begin(coordinates),
			end(coordinates),
			[&]{ return -alpha+(double)2*alpha*iterator++/resolution; }
		);
	}

	cout<<"enter order: "; cin>>order;
	{
		string filename(string("sine")+to_string(order)+".dat");
		ofstream file(filename.c_str());

		auto sine_sequence=maclaurin::sine<long>(beta,order);
		cout<<"\nsine sequence: ";
		copy(begin(sine_sequence),end(sine_sequence),ostream_iterator<long>(cout," "));
		cout<<endl;

		file<<"#x y\n";

		//for sine the denominator is coefficient_0*beta
		auto denominator=sine_sequence.front()*beta;
		for(auto coordinate:coordinates){
			int index{0};
			long numerator{0};
			for(auto coefficient:sine_sequence){
				numerator+=coefficient*power(coordinate,2*index+1);
				index++;
			}
			file<<coordinate<<" "<<((double)(numerator))/(denominator)<<endl;
		}
	}{
		string filename(string("cosine")+to_string(order)+".dat");
		ofstream file(filename.c_str());

		auto cosine_sequence=maclaurin::cosine<long>(beta,order);
		cout<<"\ncosine sequence: ";
		copy(begin(cosine_sequence),end(cosine_sequence),ostream_iterator<long>(cout," "));
		cout<<endl;

		file<<"#x y\n";
		//for cosine thedenominator is just coefficient_0
		auto denominator=cosine_sequence.front();
		for(auto coordinate:coordinates){
			int index{0};
			long numerator{0};
			for(auto coefficient:cosine_sequence){
				numerator+=coefficient*power(coordinate,2*index);
				index++;
			}
			file<<coordinate<<" "<<((double)(numerator))/denominator<<endl;
		}
	}
}

CXX = g++-5.0
CXXFLAGS = -std=c++14 -I. -I../ -Wfatal-errors -fdiagnostics-color -fmessage-length=64 -O2
LDFLAGS = -lpthread -lrt


all: work clean

work:work.o
	$(CXX) -o $@ $^ $(LDFLAGS)

work.o:work.cpp
	$(CXX) -c $(CXXFLAGS) $<

.PHONY: clean

clean: 
	rm -rf *.o