Machine Based Calculator : Inpost C Source Code Version 1.6


  1. #include "inpost.h"
  2. #include "stdlib.h"
  3. #include <math.h>
  4. #include "inpre.h"
  5.  
  6.  
  7. adrStack alokasiStack(infotype x)
  8. {
  9.         adrStack p = (adrStack) malloc(sizeof(ElmtStack));
  10.         p->info = x;
  11.         p->next = nil;
  12.         return p;  
  13. }
  14.  
  15. void    menu()
  16. {      
  17.         Stack S,T,U,V,W,X,Y,Z;
  18.         infotype a;
  19.         int i,j,h,l;
  20.         char pil;
  21.         adrStack b;
  22.        
  23.         createStack(&S);
  24.         createStack(&T);
  25.         createStack(&V);
  26.         createStack(&W);
  27.         createStack(&X);
  28.         createStack(&Y);
  29.        
  30.         printf("\nLanjut gan?\t Masukkan satu untuk melanjutkan :\t");
  31.         scanf("%d", &l);
  32.        
  33.         if (l ==1)
  34.         {
  35.             printf("\nMasukkan banyaknya token :");
  36.             scanf("%d",&j);
  37.             while(j % 2 == 0)
  38.             {  
  39.                 printf("\nMaaf anda tidak boleh memasukkan karakter genap");
  40.                 printf("\nMasukkan banyaknya token :");
  41.                 scanf("%d",&j);
  42.             }
  43.             printf("\n======MENU======\n");
  44.             printf("\n1. Convert Infix to Postfix\n");
  45.             printf("\n2. Convert Infix to Prefix\n");
  46.             printf("\n3. Exit\n");
  47.             printf("\nMasukkan pilihan : ");
  48.             getchar();
  49.             scanf("%c",&pil);
  50.                 switch (pil)
  51.                 {
  52.                     case ‘1’    :   printf("Infix to Postfix\n");
  53.                                     printf("Masukkan ekspresi dalam bentuk infix\n");
  54.                                     for (i=0; i<j; i++)
  55.                                     {
  56.                                         a = inputS();
  57.                                         convertInfixPost(a, &S, &T);
  58.                                     }
  59.                                     appendStack(&S, &T);
  60.                                     U = reverseStack(&T);
  61.                                     printf("Ekspresi dalam postfix ");
  62.                                     printStack(U);
  63.                                     h = hitungPost(U);
  64.                                     printf("\nHasil dari operasi ini adalah %d", h);
  65.                                     menu();
  66.                                     break;
  67.                     case ‘2’    :   printf("Infix to Prefix\n");
  68.                                     printf("\nMasukkan ekspresi dalam bentuk infix\n");
  69.                                     for (i=0; i<j; i++)
  70.                                     {
  71.                                         a = inputS();
  72.                                         push(&S, a);
  73.                                     }
  74.                                                            
  75.                                     for (i = 0; i < j; i++)
  76.                                     {
  77.                                         pop(&S, &b);
  78.                                         convertInfixPre(b->info, &V, &W);
  79.                                         convertInfixPost(b->info, &X, &Y);
  80.                                     }
  81.                                     /*algoritma untuk menghitung(postfix)*/
  82.                                     appendStack(&X, &Y);
  83.                                     Z = reverseStack(&Y);
  84.                                     /*Algoritma lanjutan dari prefix*/
  85.                                     appendStack(&V, &W);
  86.                                     printf("Ekspresi dalam prefix ");
  87.                                     printStack(W);
  88.                                    
  89.                                     h = hitungPre(Z);
  90.                                     printf("\n Hasil dari operasi ini adalah %d", h);
  91.                                     menu();
  92.                                     break;
  93.                     default     :   printf("\n Maaf Pilihan anda tidak valid");
  94.                                     break;
  95.                 }      
  96.         }
  97.         else if (l != 1)
  98.         {
  99.             printf("\nMakasih gan ! \n");
  100.         }
  101. }
  102.  
  103. infotype inputS()
  104. {
  105.         infotype x;
  106.         printf("\nMasukkan token : ");
  107.         scanf("%s", &x);
  108.         return x;
  109. }
  110.  
  111. boolean isEmpty(Stack *S)
  112. {
  113.         return(S->top == nil);
  114. }
  115.  
  116. void printStack(Stack S)
  117. {
  118.     adrStack p;
  119.     for(p = S.top; p != nil; p = p->next )
  120.     {
  121.         printf("%c ", p->info);    
  122.     }
  123. }
  124. void createStack(Stack *S)
  125. {
  126.         (*S).top = nil;
  127. }
  128.  
  129. void push(Stack *S, infotype x)
  130. {
  131.         adrStack p;
  132.         p = alokasiStack(x);
  133.         p->next = S->top;
  134.         S->top = p;
  135. }
  136.  
  137. void pop(Stack *S, adrStack *p)
  138. {  
  139.         *p = S->top;
  140.         S->top = S->top->next;
  141. }
  142.  
  143. void popWithNotice(Stack *S, adrStack *p)
  144. {  
  145.         *p = S->top;
  146.         S->top = S->top->next;
  147.         printf("Elemen %d diambil\n", (*p)->info);
  148. }
  149.  
  150. Stack createExist(Stack *T)
  151. {
  152.     Stack S;
  153.     createStack(&S);
  154.     adrStack p,q;
  155.     int i=0;
  156.    
  157.     p = T->top;
  158.     while(p!=nil)
  159.     {
  160.         pop(T, &q);
  161.         push(&S, q->info);
  162.         i+=1;
  163.         p=p->next;
  164.     }
  165.     //validasi doang cuy
  166.     if (p == nil)
  167.     {
  168.         printf("Berhasil memindahkan %d elemen \n",i);
  169.     }
  170.     return S;
  171. }
  172.  
  173. void searchElmt(Stack *S, infotype x)
  174. {
  175.     int i=0;
  176.     adrStack q, p;
  177.     boolean temu = false;
  178.     Stack T;
  179.     createStack(&T);
  180.     p = S->top;
  181.     while(p!=nil)
  182.     {
  183.         i+=1;
  184.         pop(S, &q);
  185.         if (q->info == x)
  186.         {
  187.             pop(S, &q);
  188.             temu = true;
  189.         }
  190.         push(&T, q->info);
  191.         p = p->next;
  192.     }
  193.     if (p==nil && !temu)
  194.     {
  195.         printf("\nData tidak ditemukan");
  196.     }
  197.     *S = createExist(&T);
  198. }
  199.  
  200. void appendStack(Stack *S, Stack *T)
  201. {
  202.         adrStack X;
  203.         while (S->top != nil)
  204.         {
  205.             pop(S, &X);
  206.             push(T, X->info);
  207.         }
  208. }
  209.  
  210.  
  211. void appendStackV(Stack *S, Stack *T)
  212. {
  213.         adrStack X,Y;
  214.         if(S->top != nil && S->top->next != nil)
  215.         {
  216.             pop(S, &X);
  217.             pop(S, &Y);
  218.             push(T, Y->info);
  219.             push(T, X->info);
  220.         }
  221.         else
  222.         {
  223.             while (S->top != nil)
  224.             {
  225.             pop(S, &X);
  226.             push(T, X->info);
  227.             }
  228.         }
  229.        
  230. }
  231.  
  232. Stack reverseStack(Stack *S)
  233. {
  234.     Stack T;
  235.     adrStack q,p = S->top;
  236.     int i=0;
  237.     createStack(&T);
  238.     while(p!=nil)
  239.     {
  240.         pop(S, &q);
  241.         push(&T, q->info);
  242.         i+=1;
  243.         p=p->next;
  244.     }
  245.     return T;
  246. }
  247.  
  248. int precendence(infotype X)
  249. {
  250.     if (X==‘^’)
  251.         return 4;
  252.     else    if (X==‘*’ || X==‘/’ || X==‘%’)
  253.                 return 3;
  254.             else    if (X==‘+’ || X==‘-‘)
  255.                         return 2;
  256.                     else    if (X == ‘(‘ || X ==‘)’)
  257.                                 return 1;
  258.                             else
  259.                                 return 0;
  260.    
  261. }
  262.  
  263. int pemangkatan(int x, int k)
  264. {
  265.     int pangkat, i;
  266.     if (k == 0)
  267.     {
  268.         pangkat =1;
  269.     }
  270.     else
  271.     {
  272.         pangkat = 1;
  273.         for (i = 1; i <= k ; i++)
  274.         {
  275.             pangkat = pangkat * x;
  276.         }
  277.        
  278.     }
  279.     return pangkat;
  280. }
  281.  
  282. void convertInfixPost(infotype X,Stack *S, Stack *T)
  283. {
  284.     adrStack opr;
  285.    
  286.     if (isdigit(X) || isalpha(X))
  287.     {
  288.         push(T, X);
  289.     }
  290.    
  291.     if (X == ‘+’ || X == ‘-‘ || X==‘*’ || X==‘/’ || X  == ‘%’ || X  == ‘-‘ || X  == ‘^’ || X==‘(‘)
  292.     {
  293.         if (S->top != nil && !isdigit(S->top->info))
  294.         {
  295.             pop(S, &opr);
  296.             if(X == ‘(‘)
  297.             {
  298.                 push(S, opr->info);
  299.                 push(S, X);
  300.             }
  301.                 else    if(precendence(opr->info) >= precendence(X))
  302.                         {  
  303.                                 push(T,opr->info);
  304.                                 push(S, X);
  305.                         }
  306.                         else
  307.                         {
  308.                             push(S, opr->info);
  309.                             push(S, X);
  310.                         }
  311.         }
  312.         else    if (S->top == nil)
  313.                     push(S, X);
  314.     }
  315.    
  316.    
  317.     if (X==‘)’)
  318.     {
  319.         while (S->top != nil)
  320.         {
  321.             Stack U;
  322.             createStack(&U);
  323.             pop(S, &opr);
  324.             if (opr->info == ‘(‘)
  325.             {
  326.                 push(&U, opr->info);
  327.                 opr = nil;
  328.             }
  329.             else    if (opr->info != ‘(‘)
  330.                     {
  331.                         push(T, opr->info);
  332.                     }
  333.         }
  334.     }
  335.    
  336. }  
  337.  
  338. void convertInfixPre(infotype X,Stack *S, Stack *T)
  339. {
  340.     adrStack opr;
  341.    
  342.     if (isdigit(X) || isalpha(X))
  343.     {
  344.         push(T, X);
  345.     }
  346.    
  347.     if (X == ‘+’ || X == ‘-‘ || X==‘*’ || X==‘/’ || X  == ‘%’ || X  == ‘-‘ || X  == ‘^’ || X==‘)’)
  348.     {
  349.         if (S->top != nil && !isdigit(S->top->info))
  350.         {
  351.             pop(S, &opr);
  352.             if(X == ‘)’)
  353.             {
  354.                 push(S, opr->info);
  355.                 push(S, X);
  356.             }
  357.                 else    if(precendence(opr->info) >= precendence(X))
  358.                         {  
  359.                             push(T,opr->info);
  360.                             push(S, X);
  361.                         }
  362.                         else
  363.                         {
  364.                             push(S, opr->info);
  365.                             push(S, X);
  366.                         }
  367.         }
  368.         else    if (S->top == nil)
  369.                     push(S, X);
  370.     }
  371.    
  372.    
  373.     if (X==‘(‘)
  374.     {
  375.         while (S->top != nil)
  376.         {
  377.             Stack U;
  378.             createStack(&U);
  379.             pop(S, &opr);
  380.             if (opr->info == ‘)’)
  381.             {
  382.                 push(&U, opr->info);
  383.                 opr = nil;
  384.             }
  385.             else    if (opr->info != ‘)’)
  386.                     {
  387.                         push(T, opr->info);
  388.                     }
  389.         }
  390.     }
  391.    
  392. }  
  393.  
  394. int hitungPre(Stack S)
  395. {
  396.     int a;
  397.     Stackint T;
  398.     createStacki(&T);
  399.     adrStack p,q;
  400.     adiStack t,u;
  401.     p = S.top;
  402.     while(p != nil)
  403.     {
  404.         pop(&S, &q);
  405.         if (isdigit(q->info))
  406.         {
  407.             a = atoi(&q->info);
  408.             pushi(&T, a);
  409.         }
  410.         else    if (!isdigit(q->info))
  411.                 {
  412.                     switch(q->info)
  413.                     {
  414.                         case ‘+’:
  415.                                     popi(&T, &t);
  416.                                     popi(&T, &u);
  417.                                     pushi(&T, t->info + u->info);
  418.                                     break;
  419.                         case ‘*’:   popi(&T, &t);
  420.                                     popi(&T, &u);
  421.                                     pushi(&T, t->info * u->info);
  422.                                     break;
  423.                         case ‘/’:   popi(&T, &t);
  424.                                     popi(&T, &u);
  425.                                     pushi(&T, u->info / t->info);
  426.                                     break;
  427.                         case ‘-‘:   popi(&T, &t);
  428.                                     popi(&T, &u);
  429.                                     pushi(&T, u->info t->info);
  430.                                     break;
  431.                         case ‘^’:   popi(&T, &t);
  432.                                     popi(&T, &u);
  433.                                     pushi(&T, pemangkatan(t->info, u->info));
  434.                                     break;
  435.                         case ‘%’:   popi(&T, &t);
  436.                                     popi(&T, &u);
  437.                                     pushi(&T, t->info % u->info);
  438.                                     break;
  439.                     }
  440.                 }
  441.     p = p->next;
  442.     }
  443.     popi(&T, &t);
  444.     return t->info;
  445. }
  446.  
  447. int hitungPost(Stack S)
  448. {
  449.     int a;
  450.     Stackint T;
  451.     createStacki(&T);
  452.     adrStack p,q;
  453.     adiStack t,u;
  454.     p = S.top;
  455.     while(p != nil)
  456.     {
  457.         pop(&S, &q);
  458.         if (isdigit(q->info))
  459.         {
  460.             a = atoi(&q->info);
  461.             pushi(&T, a);
  462.         }
  463.         else    if (!isdigit(q->info))
  464.                 {
  465.                     switch(q->info)
  466.                     {
  467.                         case ‘+’:
  468.                                     popi(&T, &t);
  469.                                     popi(&T, &u);
  470.                                     pushi(&T, t->info + u->info);
  471.                                     break;
  472.                         case ‘*’:   popi(&T, &t);
  473.                                     popi(&T, &u);
  474.                                     pushi(&T, t->info * u->info);
  475.                                     break;
  476.                         case ‘/’:   popi(&T, &t);
  477.                                     popi(&T, &u);
  478.                                     pushi(&T, u->info / t->info);
  479.                                     break;
  480.                         case ‘-‘:   popi(&T, &t);
  481.                                     popi(&T, &u);
  482.                                     pushi(&T, u->info t->info);
  483.                                     break;
  484.                         case ‘^’:   popi(&T, &t);
  485.                                     popi(&T, &u);
  486.                                     pushi(&T, pemangkatan(u->info, t->info));
  487.                                     break;
  488.                         case ‘%’:   popi(&T, &t);
  489.                                     popi(&T, &u);
  490.                                     pushi(&T, t->info % u->info);
  491.                                     break;
  492.                     }
  493.                 }
  494.     p = p->next;
  495.     }
  496.     popi(&T, &t);
  497.     return t->info;
  498. }
  499.  

One thought on “Machine Based Calculator : Inpost C Source Code Version 1.6

  1. Pingback: Tugas Besar “Machine Based Calculator” : Kalkulator Konversi Infix ke Postfix dan Prefix « The TWOH's Computer Engineering and Science

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s