float permintaan,persediaan, permintaan1, persediaan1, input_permintaan, input_persediaan ;          // Inisialilasasi Input
float m_permintaan, m_persediaan, m_permintaan1, m_persediaan1;    // Inisialilasasi Derajat Keanggotaan 
float turun, naik;                                                 // Inisialilasasi Membership Function permintaan
float sedikit, banyak;                                             // Inisialilasasi Membership Function persediaan
float turun_1, naik_1;                                             // Inisialilasasi Membership yang aktif
float sedikit_1, banyak_1;                                         // Inisialilasasi Membership yang aktif
float berkurang_max=0, bertambah_max=0;                            // Inisialilasasi Defuzzification
float output;                                                      // Inisialilasasi defuzzification
float z2, z1, x1, x2, uz1, uz2;
float A, B;
int sel_;
float M1, M2, M3;
float a1, a2, a3;
float berkurang1 = 2000, bertambah1 = 7000 , tambahminkurang = 5000;  // Inisialilasasi Membership Function berkurang dan bertambah

//==================================================INTEGRAL

float f(float x) {
  if (B > 0 && sel_ == 0) {
    return ((x - A) / B) * x;
  }
  else if (B > 0 && sel_ == 1) {
    return ((A - x) / B) * x;
  }
  else {
    return A * x;
  }
}

float trapezoidal(float f(float x), float a, float b, float n) {
  float h, integral, x, sum = 0;
  int i;
  h = fabs(b - a) / n;
  for (i = 1; i < n; i++) {
    x = a + i * h;
    sum = sum + f(x);
  }
  integral = h * (f(a) + 2 * sum + f(b)) / 2;
  return integral;
}

float fx(float limd, float limu, float a, float b, int sel) {
  int n, i = 2;
  float h, x, integral, eps = 0.1, integral_new;
  A = a;
  B = b;
  sel_ = sel;
  integral_new = trapezoidal(f, limd, limu, i);
  do {
    integral = integral_new;
    i = i + 2;
    integral_new = trapezoidal(f, limd, limu, i);
  } while (fabs(integral_new - integral) >= eps);
  /*Print the answer */
  return integral_new;
}



// ------------------------------------------------- Fuzzification ------------------------------------------------------------

float mf_permintaan(float a, float b)              // Mencari Derajat keanggotaan membership function segitiga permintaan
   {
     if (permintaan==a) {m_permintaan= 1;}
     if (permintaan>=a&&permintaan<=b) {m_permintaan=(b-permintaan)/4000;}
     if (permintaan==b) {m_permintaan= 0;}
     return m_permintaan;
   }

float mf_permintaan1(float a, float b)              // Mencari Derajat keanggotaan membership function segitiga permintaan
   {
     if (permintaan1==a) {m_permintaan1= 0;}
     if (permintaan1>=a&&permintaan1<=b) {m_permintaan1=(permintaan1-a)/4000;}
     if (permintaan1==b) {m_permintaan1= 1;}
     return m_permintaan1;
   }

float mf_persediaan(float a, float b)          // Mencari Derajat keanggotaan membership function segitiga Jumlah persediaan
   {
     if (persediaan==a) {m_persediaan= 1;}
     if (persediaan>=a&&persediaan<=b) {m_persediaan=(b-persediaan)/500;}
     if (persediaan==b) {m_persediaan= 0;}
     return m_persediaan;
   }

float mf_persediaan1(float a, float b)          // Mencari Derajat keanggotaan membership function segitiga Jumlah persediaan
   {
     if (persediaan1==a) {m_persediaan1= 0;}
     if (persediaan1>=a&&persediaan1<=b) {m_persediaan1=(persediaan1-a)/500;}
     if (persediaan1==b) {m_persediaan1= 1;}
     return m_persediaan1;
   }
                                                                                                                                          
void setup() {
  Serial.begin(9600);
   input_permintaan = 4000;
   input_persediaan = 300;

   permintaan = input_permintaan;
   permintaan1 = input_permintaan;
   persediaan = input_persediaan;
   persediaan1 = input_persediaan;

  Serial.println("INPUT==================================");
  Serial.print("Permintaan: ");
  Serial.println(float(input_permintaan));
  Serial.print("persediaan: ");
  Serial.println(float( input_persediaan));
  Serial.println(" ");

// ----------------------------------------- Membership Function ---------------------------------------------
 Serial.println("FUZZIFIKASI==================================");
 if(permintaan>=1000&&permintaan<=5000)
    {mf_permintaan(1000,5000);  turun=m_permintaan;   
      Serial.print("Turun :");
      Serial.println(mf_permintaan(1000,5000));     }                            //  turun
 float turunn = mf_permintaan(1000,5000);     

 if(permintaan1>=1000&&permintaan1<=5000)
    {mf_permintaan1(1000,5000);  naik=m_permintaan;    
       Serial.print("Naik :");
      Serial.println(mf_permintaan1(1000,5000)); }                     //  naik
 float naikk = mf_permintaan1(1000,5000);
      Serial.println(" ");

 if(persediaan>=100&&persediaan<=600)
    {mf_persediaan(100,600);  sedikit=m_persediaan;   
      Serial.print("Sedikit :");
      Serial.println(mf_persediaan(100,600));     }                           //  sedikit
 float sedikitt = mf_persediaan(100,600);

 if(persediaan1>=100&&persediaan1<=600)
    {mf_persediaan1(100,600);  banyak=m_persediaan;    
      Serial.print("Banyak :");
      Serial.println(mf_persediaan1(100,600)); }                     //  banyak
  float banyakk = mf_persediaan(100,600);    
      Serial.println(" ");
 //  ----------------------------------------- RULE mechanism Inferens  ----------------------------------------


  if (turunn >0)         {turun_1 = 1;}          else {turun_1  = 0;}
  if (naikk >0)          {naik_1 = 1;}           else {naik_1 = 0;}

  if (sedikitt >0)       {sedikit_1 = 1;}        else {sedikit_1 = 0;}
  if (banyakk >0)        {banyak_1 = 1;}         else {banyak_1 = 0;}

  
  float berkurang[2]={0,1};                                                                                        // Berkurang
  {  
  if (turun_1==1 && banyak_1==1)                   {berkurang[1]=min(turunn,banyakk);}                   else {berkurang[1]=0;}   
  if (turun_1==1 && sedikit_1==1)                  {berkurang[2]=min(turunn,sedikitt);}                  else {berkurang[2]=0;}   
  }
  
  float bertambah[2]={0,1};                                                                                            // bertambah
  {
  if (naik_1==1 && banyak_1==1)                    {bertambah[1]=min(naikk,banyakk);}                    else {bertambah[1]=0;}
  if (naik_1==1 && sedikit_1==1)                   {bertambah[2]=min(naikk,sedikitt);}                   else {bertambah[2]=0;} 
  } 
                                                                                                                                       
  berkurang_max=berkurang[0];    int index2=0;  for (int b=1; b<=2; b++)  {   if(berkurang_max<=berkurang[b])      { berkurang_max=berkurang[b];       index2=b;}  }
  bertambah_max=bertambah[0];    int index3=0;  for (int c=1; c<=2; c++)  {   if(bertambah_max<=bertambah[c])      { bertambah_max=bertambah[c];       index3=c;}  }


Serial.println("HASIL RULE=================================="); 
Serial.print("berkurang_max: ");
Serial.println(float(berkurang_max));
Serial.print("bertambah_max: ");
Serial.println(float(bertambah_max));
Serial.println();


if (bertambah_max>berkurang_max){
x1 = berkurang_max*tambahminkurang;
uz1 = x1 + berkurang1;
Serial.print("uz1: ");
Serial.println(uz1);

x2 = bertambah_max*tambahminkurang;
uz2 = x2 + berkurang1;
Serial.print("uz2: ");
Serial.println(uz2);
Serial.println();
}

else if(bertambah_max<berkurang_max){
x1 = berkurang_max*tambahminkurang;
uz1 = bertambah1 - x1 ;
Serial.print("uz1: ");
Serial.println(uz1);

x2 = bertambah_max*tambahminkurang;
uz2 = bertambah1 - x2;
Serial.print("uz2: ");
Serial.println(uz2);
Serial.println();

}

 Serial.println("DEFUZZIFIKASI==================================");
  M1 = fx(0, uz1, berkurang_max, 0, 0 );
  Serial.print("M1: ");
  Serial.println(M1);

  M2 = fx(uz1, tambahminkurang, berkurang1, tambahminkurang ,  0);
  Serial.print("M2: ");
  Serial.println(M2);

  M3 = fx(uz2, bertambah1, bertambah_max, 0, 0 );
  Serial.print("M3: ");
  Serial.println(M3);
  Serial.println();

  a1 = uz1*berkurang_max;
  Serial.print("A1: ");
  Serial.println(a1);

  a2 = ((uz2-uz1)*(bertambah_max + berkurang_max))/2;
  Serial.print("A2: ");
  Serial.println(a2);

  a3 = (bertambah1-uz2)*bertambah_max;
  Serial.print("A3: ");
  Serial.println(a3);
  Serial.println();

  Serial.println("OUTPUT==================================");
  output = (M1+M2+M3)/(a1+a2+a3);
  Serial.print("HASIL: ");
  Serial.println(output);
  

}
void loop() {
   
}