/*
this program will simulate the spreading of a disease through a 
grid of people, starting from a user-defined person. It will count
the number of turns taken before everyone on the grid is immunized
to the disease after having caught it once.
This program will user the SIR model (Susceptible, Infectious, Recovered)
 and cellular automata to simulate the people in the grid.
*/
#include <iostream>
using namespace std;

/* Any and all global variables */
const int SIZE = 8; //Size of the square person array

/* Any and all functions */
void gridDefaultify(char[][SIZE], int);
	//Purpose: Sets each item in the person array to 's'
	//Parameters: A square, two-dimensional array
	//            The size of that array's bounds
void gridDisplay(char[][SIZE], int);
	//Purpose: Formats and prints the information in the person grid
	//Parameters: A square, two-dimensional array
	//            The value of the current day
void nextTurn(char[][SIZE], char[][SIZE], int&);
	//Purpose: Updates the grid of people, and the current day
	//Parameters: Two square, two-dimensional arrays
	//            A reference to the current day (so that it can be updated)
int countInfected(char[][SIZE], int);
	//Purpose: Counts the number of infectious people on the grid
	//Parameters: A square, two-dimensional array
	//            The size of that array's bounds


int main(){
	int currentDay = 0; //Infection begins on day 0, and ends one day after the last person is Recovered
	char gridCurrent[SIZE][SIZE]; //Grid of all people
	char gridUpdate[SIZE][SIZE]; //Where the user chooses to start the infection
	int xToInfect;
	int yToInfect; //Set of coordinates for the initial infection position, given by user
	
	//Initializes the grids to all 's'
	gridDefaultify(gridCurrent, SIZE);
	gridDefaultify(gridUpdate, SIZE);
	
	//The below block gets the initial infection coordinates from the user
	cout << "Please enter a location to infect: ";
	while(true){
		cin >> xToInfect >> yToInfect;

		xToInfect--;
		yToInfect--;
		
		if(xToInfect < 0 || yToInfect < 0 || xToInfect >= SIZE || yToInfect >= SIZE){
			cout << "Those coordinates are outside the bounds of this region." << endl;
			cout << "Please enter another location to infect: ";
			continue;
		} else {
			gridCurrent[xToInfect][yToInfect] = 'i';
			break;
		}
	}
	
	//Displays the initial state of the grid
	gridDisplay(gridCurrent, currentDay);
	
	//The below block will display and update the grid until the infection is done.
	while(true){
		nextTurn(gridCurrent, gridUpdate, currentDay);
		gridDisplay(gridCurrent, currentDay);
		if(countInfected(gridCurrent, SIZE) == 0) break; //Once there are no more infected, the game is done
	}
	
	//Displays the number of days taken for the infection to end
	cout << "It took " << currentDay + 1 << " days for the outbreak to end";
	
	cout << endl;
	return 0;
}

void gridDefaultify(char arr[][SIZE], int arrSize){
	for(int x = 0; x < arrSize; x++){
		for(int y = 0; y < arrSize; y++){
			arr[x][y] = 's'; //Sets all items in the passed-in array to 's'
		}
	}
	return;
}

void gridDisplay(char arr[][SIZE], int day){
	cout << "Day " << day << endl; //Prints the current day
	for(int x = 0; x < SIZE; x++){
		for(int y = 0; y < SIZE; y++){
			cout << arr[x][y] <<" "; //Prints the array's contents
		}
		cout << endl; //Formats with newlines
	}
	cout << endl; //Some spacing
	return;
}

void nextTurn(char today[][SIZE], char update[][SIZE], int& day){
	day++; //Updates the day
	int xCheck; //X coordinate to be checked
	int yCheck; //Y coordinate to be checked
	
	for(int x = 0; x < SIZE; x++){
		for(int y = 0; y < SIZE; y++){
			//Sets all 'i' to 'r' in the new grid
			if(today[x][y] == 'i' || today[x][y] == 'r'){
				update[x][y] = 'r'; //Updates all infectious to recovered, and keeps current recovered
			}
			if(today[x][y] == 's'){									// If the person is susceptible...
				for(int xCheck = x-1; xCheck <= x+1; xCheck++){		// Check all x coordinates around the person
					for(int yCheck = y-1; yCheck <= y+1; yCheck++){	// Check all y coordinates around the person
						if(xCheck == x && yCheck == y){
																	// Don't check at the person because there is no need to check there
						} else {
							if(xCheck >= 0 && yCheck >= 0 && xCheck < SIZE && yCheck < SIZE){ // Make sure the checked coordinates are in bounds
								if(today[xCheck][yCheck] == 'i'){	//Is the person at the checked coordinates infected?
									update[x][y] = 'i';				//If so, update the 's' to 'i' in the new grid
								}
							}
						}
					}
				}
			}
		}
	}
	
	for(int x = 0; x < SIZE; x++){
		for(int y = 0; y < SIZE; y++){
			today[x][y] = update[x][y]; //Updates today's grid with the new values
		}
	}
}

int countInfected(char arr[][SIZE], int arrSize){
	int count = 0;
	
	for(int x = 0; x < arrSize; x++){
		for(int y = 0; y < arrSize; y++){
			if(arr[x][y] == 'i') count++; //Increments count for each infected person in the grid
		}
	}
	
	return count;
}

#include <iostream>
#include <cstring>
int main(int argc, char** argv){
	//With decimal
	if(strstr(argv[1], ".") != nullptr){
		int i = 0;
		//Skip i to first non 0 digit
		while(argv[1][i] < '1' || argv[1][i] > '9') ++i;
		//If digit comes before decimal
		if((argv[1] + i) < strstr(argv[1], ".")){	//Good example of pointer arithmetic
			std::cout << strlen(argv[1] + i) - 1 << std::endl;	//Another good example
		}else{
			//If digit is after decimal
			std::cout << strlen(argv[1] + i) << std::endl;
		}
	}else{
	//Without decimal
		int m = 0;
		int i = 0;
		while(argv[1][i] < '1' || argv[1][i] > '9') ++i;	//In case of some number like 0045
		for(; argv[1][i] != '\0'; ++i){
			if(argv[1][i] >= '1' && argv[1][i] <= '9') m = i + 1;
		}
		std::cout << m << std::endl;
	}
	return 0;
}

using namespace std; 
  
class Hash 
{ 
    int BUCKET;    // No. of buckets 
  
    // Pointer to an array containing buckets 
    list<int> *table; 
public: 
    Hash(int V);  // Constructor 
  
    // inserts a key into hash table 
    void insertItem(int x); 
  
    // deletes a key from hash table 
    void deleteItem(int key); 
  
    // hash function to map values to key 
    int hashFunction(int x) { 
        return (x % BUCKET); 
    } 
  
    void displayHash(); 
}; 
  
Hash::Hash(int b) 
{ 
    this->BUCKET = b; 
    table = new list<int>[BUCKET]; 
} 
  
void Hash::insertItem(int key) 
{ 
    int index = hashFunction(key); 
    table[index].push_back(key);  
} 
  
void Hash::deleteItem(int key) 
{ 
  // get the hash index of key 
  int index = hashFunction(key); 
  
  // find the key in (inex)th list 
  list <int> :: iterator i; 
  for (i = table[index].begin(); 
           i != table[index].end(); i++) { 
    if (*i == key) 
      break; 
  } 
  
  // if key is found in hash table, remove it 
  if (i != table[index].end()) 
    table[index].erase(i); 
} 
  
// function to display hash table 
void Hash::displayHash() { 
  for (int i = 0; i < BUCKET; i++) { 
    cout << i; 
    for (auto x : table[i]) 
      cout << " --> " << x; 
    cout << endl; 
  } 
} 
  
// Driver program  
int main() 
{ 
  // array that contains keys to be mapped 
  int a[] = {15, 11, 27, 8, 12}; 
  int n = sizeof(a)/sizeof(a[0]); 
  
  // insert the keys into the hash table 
  Hash h(7);   // 7 is count of buckets in 
               // hash table 
  for (int i = 0; i < n; i++)  
    h.insertItem(a[i]);   
  
  // delete 12 from hash table 
  h.deleteItem(12); 
  
  // display the Hash table 
  h.displayHash(); 
  
  return 0; 
}

/*
Algorithm:
Step 1: Get radius of the cylinder from the user and store in variable r
Step 2: Get height of the cylinder from the user and store in variable h
Step 3: Multiply radius * radius * height * pi and store in v
Step 4: Display the volume
*/

#include <iostream>
using namespace std;


int main()
{
        float r; //define variable for radius
        float h; //define variable for height
        float v;
        float pi;
        pi=3.1416;

        cout<<"Enter radius:";
        cin>>r;

        cout<<"Enter height:";
        cin>>h;

        v=r*r*h*pi;  //compute volume

        cout<<"Radius:"<<r<<"\tHeight:"<<h<<endl; //display radius and height

        cout<<"\n************************\n";

        cout<<"Volume:"<<v<<endl;//display volume

        return 0;
}

//Leif Messinger
//Compile with C++ 20
#include <iostream>
#include <ranges>
#include <vector>
#include <functional>
#include <cctype> //toupper
#include <cxxabi.h>

template <typename T>
void printType(){
    std::cout << abi::__cxa_demangle(typeid(T).name(), NULL, NULL, NULL) << std::endl;
}

template <typename T>
class Slicer{
    public:
        T begin_;
        T end_;
        T trueEnd;
        Slicer(T begin, T end): begin_(begin), end_(begin), trueEnd(end){}
        template<typename U>
        Slicer(U&& vec) : begin_(vec.begin()), end_(vec.begin()), trueEnd(vec.end()){}
        Slicer& finish(){
            begin_ = end_;
            end_ = trueEnd;
            return (*this);
        }
        Slicer& to(long int index){
            begin_ = end_;
            if(index > 0){
                end_ = (begin_ + index);
            }else{
                index *= -1;
                end_ = (trueEnd - index);
            }
            return (*this);
        }
        Slicer& operator[](long int index){
            return to(index);
        }
        T begin(){
            return this->begin_;
        }
        T end(){
            return this->end_;
        }
        Slicer& operator()(std::function<void(decltype(*begin_))> func) {
            for(decltype(*begin_) thing : (*this)){
                func(thing);
            }
            return (*this);
        }
};
static_assert(std::ranges::range< Slicer<std::vector<int>::const_iterator> >);

int main(){
    std::string vec = "abcdefghijklmnopqrstuvwxyz";
    Slicer<std::string::const_iterator> bruh(vec);
    
    //printType<decltype(bruh)>();

    bruh.to(3)([](char yeet){
        std::cout << yeet;
    })
    .to(-1)([](char yeet){
        std::cout << char(std::toupper(yeet));
    }).finish()([](char yeet){
        std::cout << yeet << yeet << yeet << yeet << yeet;
    });
    
    std::cout << std::endl << std::endl;
    
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    Slicer<int*> arrSlicer(arr, arr + (sizeof(arr)/sizeof(int)));
    
    std::cout << "[";
    arrSlicer.to(-1)([](int yeet){
        std::cout << yeet << ", ";
    }).finish()([](int yeet){
        std::cout << yeet << "]" << std::endl;
    });

    return 0;
}

//From https://create.arduino.cc/projecthub/abhilashpatel121/easyfft-fast-fourier-transform-fft-for-arduino-9d2677
#include <cmath>
#include <iostream>
const unsigned char sine_data[] = {	//Quarter a sine wave
	0, 
	4, 9, 13, 18, 22, 27, 31, 35, 40, 44, 
	49, 53, 57, 62, 66, 70, 75, 79, 83, 87, 
	91, 96, 100, 104, 108, 112, 116, 120, 124, 127, 
	131, 135, 139, 143, 146, 150, 153, 157, 160, 164, 
	167, 171, 174, 177, 180, 183, 186, 189, 192, 195, //Paste this at top of program
	198, 201, 204, 206, 209, 211, 214, 216, 219, 221, 
	223, 225, 227, 229, 231, 233, 235, 236, 238, 240, 
	241, 243, 244, 245, 246, 247, 248, 249, 250, 251, 
	252, 253, 253, 254, 254, 254, 255, 255, 255, 255
};
float sine(int i){	//Inefficient sine
	int j=i;
	float out;
	while(j < 0) j = j + 360;
	while(j > 360) j = j - 360;
	if(j > -1 && j < 91) out = sine_data[j];
	else if(j > 90 && j < 181) out = sine_data[180 - j];
	else if(j > 180 && j < 271) out = -sine_data[j - 180];
	else if(j > 270 && j < 361) out = -sine_data[360 - j];
	return (out / 255);
}

float cosine(int i){	//Inefficient cosine
	int j = i;
	float out;
	while(j < 0) j = j + 360;
	while(j > 360) j = j - 360;
	if(j > -1 && j < 91) out = sine_data[90 - j];
	else if(j > 90 && j < 181) out = -sine_data[j - 90];
	else if(j > 180 && j < 271) out = -sine_data[270 - j];
	else if(j > 270 && j < 361) out = sine_data[j - 270];
	return (out / 255);
}

//Example data:

//-----------------------------FFT Function----------------------------------------------//
float* FFT(int in[],unsigned int N,float Frequency){	//Result is highest frequencies in order of loudness. Needs to be deleted.
	/*
	Code to perform FFT on arduino,
	setup:
	paste sine_data [91] at top of program [global variable], paste FFT function at end of program
	Term:
	1. in[] : Data array, 
	2. N : Number of sample (recommended sample size 2,4,8,16,32,64,128...)
	3. Frequency: sampling frequency required as input (Hz)

	If sample size is not in power of 2 it will be clipped to lower side of number. 
	i.e, for 150 number of samples, code will consider first 128 sample, remaining sample will be omitted.
	For Arduino nano, FFT of more than 128 sample not possible due to mamory limitation (64 recomended)
	For higher Number of sample may arise Mamory related issue,
	Code by ABHILASH
	Contact: [email protected] 
	Documentation:https://www.instructables.com/member/abhilash_patel/instructables/
	2/3/2021: change data type of N from float to int for >=256 samples
	*/

	unsigned int sampleRates[13]={1,2,4,8,16,32,64,128,256,512,1024,2048};
	int a = N;
	int o;
	for(int i=0;i<12;i++){		//Snapping N to a sample rate in sampleRates
		if(sampleRates[i]<=a){
			o = i;
		}
	}
		 
	int in_ps[sampleRates[o]] = {}; //input for sequencing
	float out_r[sampleRates[o]] = {}; //real part of transform
	float out_im[sampleRates[o]] = {}; //imaginory part of transform
	int x = 0; 
	int c1;
	int f;
	for(int b=0;b<o;b++){ // bit reversal
		c1 = sampleRates[b];
		f = sampleRates[o] / (c1 + c1);
		for(int j = 0;j < c1;j++){ 
			x = x + 1;
			in_ps[x]=in_ps[j]+f;
		}
	}

	
	for(int i=0;i<sampleRates[o];i++){ // update input array as per bit reverse order
		if(in_ps[i]<a){
			out_r[i]=in[in_ps[i]];
		}
		if(in_ps[i]>a){
			out_r[i]=in[in_ps[i]-a];
		} 
	}


	int i10,i11,n1;
	float e,c,s,tr,ti;

	for(int i=0;i<o;i++){ //fft
		i10 = sampleRates[i]; // overall values of sine/cosine :
		i11 = sampleRates[o] / sampleRates[i+1]; // loop with similar sine cosine:
		e = 360 / sampleRates[i+1];
		e = 0 - e;
		n1 = 0;

		for(int j=0;j<i10;j++){
			c=cosine(e*j);
			s=sine(e*j); 
			n1=j;

			for(int k=0;k<i11;k++){
				tr = c*out_r[i10 + n1]-s*out_im[i10 + n1];
				ti = s*out_r[i10 + n1]+c*out_im[i10 + n1];

				out_r[n1 + i10] = out_r[n1]-tr;
				out_r[n1] = out_r[n1]+tr;

				out_im[n1 + i10] = out_im[n1]-ti;
				out_im[n1] = out_im[n1]+ti; 

				n1 = n1+i10+i10;
			} 
		}
	}

	/*
	for(int i=0;i<sampleRates[o];i++)
	{
	std::cout << (out_r[i]);
	std::cout << ("\t"); // un comment to print RAW o/p 
	std::cout << (out_im[i]); std::cout << ("i"); 
	std::cout << std::endl;
	}
	*/


	//---> here onward out_r contains amplitude and our_in conntains frequency (Hz)
	for(int i=0;i<sampleRates[o-1];i++){ // getting amplitude from compex number
		out_r[i] = sqrt(out_r[i]*out_r[i]+out_im[i]*out_im[i]); // to increase the speed delete sqrt
		out_im[i] = i * Frequency / N;
		std::cout << (out_im[i]); std::cout << ("Hz");
		std::cout << ("\t");	// un comment to print freuency bin 
		std::cout << (out_r[i]);
		std::cout << std::endl;
	}




	x = 0; // peak detection
	for(int i=1;i<sampleRates[o-1]-1;i++){
		if(out_r[i]>out_r[i-1] && out_r[i]>out_r[i+1]){
			in_ps[x] = i; //in_ps array used for storage of peak number
			x = x + 1;
		} 
	}


	s = 0;
	c = 0;
	for(int i=0;i<x;i++){ // re arraange as per magnitude
		for(int j=c;j<x;j++){
			if(out_r[in_ps[i]]<out_r[in_ps[j]]){
				s=in_ps[i];
				in_ps[i]=in_ps[j];
				in_ps[j]=s;
			}
		}
		c=c+1;
	}
	float* f_peaks = new float[sampleRates[o]];
	for(int i=0;i<5;i++){ // updating f_peak array (global variable)with descending order
		f_peaks[i]=out_im[in_ps[i]];
	}
	return f_peaks;
}

//------------------------------------------------------------------------------------//
//main.cpp
int data[64]={
14, 30, 35, 34, 34, 40, 46, 45, 30, 4, -26, -48, -55, -49, -37,
-28, -24, -22, -13, 6, 32, 55, 65, 57, 38, 17, 1, -6, -11, -19, -34, 
-51, -61, -56, -35, -7, 18, 32, 35, 34, 35, 41, 46, 43, 26, -2, -31, -50,
-55, -47, -35, -27, -24, -21, -10, 11, 37, 58, 64, 55, 34, 13, -1, -7
};

int main(){
	const unsigned int SAMPLE_RATE = 48*1000;	//48khz
	auto result = FFT(data,64,SAMPLE_RATE);
	std::cout << result[0] << " " << result[1] << " " << result[2] << " " << result[3] << std::endl;
	delete[] result;
	return 0;
}