private void button18_Click(object sender, EventArgs e)
        {
            /** DESKRIPSI **/
            /* button18_click menangani input operator = */

            /** KAMUS DATA **/
            double solveRes;

            /** ALGORITMA **/
            value          = Double.Parse(result.Text);
            equation.Text += " " + value;

            Elemen <String> operand = new Elemen <String>(value.ToString());

            operationQueue.Enqueue(operand);

            try
            {
                solveRes    = queueOp.solveQueue();
                result.Text = (solveRes).ToString();
                ans         = solveRes;
            }
            catch (CalculatorException exc)
            {
                result.Font      = new Font(result.Font.FontFamily, 12, result.Font.Style);
                result.Text      = exc.Message;
                exception_raised = true;
            }
            finally
            {
                equal_pressed = true;
            }
        }
        private void mcButton_Click(object sender, EventArgs e)
        {
            /** DESKRIPSI **/

            /* mcButton_click menangani input tombol "MC"
             * tombol ini akan memasukkan hasil yang ada pada layar dalam suatu Queue */

            /** KAMUS DATA **/
            double          mcValue;
            Elemen <String> mcElemen;

            /** ALGORITMA **/
            if (!exception_raised)
            {
                mcValue  = Double.Parse(result.Text);
                mcElemen = new Elemen <string>(result.Text);
                memory.Enqueue(mcElemen);
            }
        }
        private void operator_Click(object sender, EventArgs e)
        {
            /** DESKRIPSI **/
            /* operator_click menangani input operator (+, -, *, /, dan akar) */

            /** KAMUS DATA **/
            Elemen <String> clicked;
            Button          b  = (Button)sender;
            bool            Eq = (b.Text == "=");

            /** ALGORITMA **/
            operation = b.Text;
            if (exception_raised)
            {
                result.Clear();
                result.Font      = new Font(result.Font.FontFamily, 18, result.Font.Style);
                result.Text      = "0";
                exception_raised = false;
            }
            value = Double.Parse(result.Text);
            if (equal_pressed)
            {
                if (operation == "√")
                {
                    equation.Text = " " + operation;
                }
                else
                {
                    equation.Text = value + " " + operation;
                }
                equal_pressed = false;
            }
            else
            {
                if (operation == "√")
                {
                    equation.Text += " " + operation;
                }
                else if (operation_pressed)
                {
                    equation.Text += " " + operation;
                }
                else
                {
                    equation.Text += " " + value + " " + operation;
                }
            }

            /** memasukkan hasil pembacaan user ke dalam Queue  **/
            Elemen <String> operand = new Elemen <String>(value.ToString());

            if (operation == "√")
            {
                clicked = new Elemen <String>("akar");
                operationQueue.Enqueue(clicked);
            }
            else if (operation_pressed)
            {
                clicked = new Elemen <String>(operation);
                operationQueue.Enqueue(clicked);
            }
            else
            {
                clicked = new Elemen <String>(operation);
                operationQueue.Enqueue(operand);
                operationQueue.Enqueue(clicked);
            }
            operation_pressed = true;
        }
Example #4
0
        private void parseInfixExpression()
        {
            /** DESKRIPSI **/
            /* Me-parse ekspresi infix sekaligus mengecek semantik dari ekspresi tersebut */

            /** KAMUS LOKAL **/
            Queue <Elemen <string> > tempQueue;
            Elemen <string>          tempElmt;
            int state;    // integer yang melambangkan keadaan pembacaan sekarang
                          // 0 -> pembacaan selesai dan berhasil
                          // 1 -> pembacaan terminal
                          // 2 -> pembacaan operator
            int negCount; // Penanda banyak minus yang berurutan

            /** ALGORITMA **/
            tempQueue = new Queue <Elemen <string> >();
            negCount  = 0;
            state     = 1; // dimulai dengan pembacaan terminal

            // 1. Loop sampai semua elemen InfixQueue habis
            while (this.expressionInfixQueue.Count != 0)
            {
                // 2. Setiap elemen di-dequeue dan ditangani sesuai state sekarang
                tempElmt = this.expressionInfixQueue.Dequeue();
                switch (state)
                {
                // 2.1  State 1 menandakan state untuk membaca terminal
                //      Kasus yang ada di sini adalah:
                //      1. Jika yang ditemukan terminal, maka berarti tidak ada masalah dan langsung dimasukkan
                //      2. Jika yang ditemukan operator, dicek terlebih dahulu operator apakah itu
                //         Jika ditemukan operator unary (seperti akar), maka diperbolehkan
                //         Kasus jika bertemu operator unary negatif yang pada program ini ditangani operator yang sama
                //         dengan binary pengurangan, dilakukan penandaan bahwa sudah ada 1 minus agar pada pembacaan terminal
                //         selanjutnya nilai negatif dapat dimasukkan ke queue (hanya jika ada 1 minus)
                //      3. Jika yang ditemukan operator, tetapi bukan "-" ataupun "akar", maka secara langsung dapat
                //         disimpulkan sintaks error dalam ekspresi dan dikeluarkan exception
                case 1:
                    //  Penanganan terminal
                    if (tempElmt.GetItem1() == "#")
                    {
                        state = 2;
                        // Penanganan terminal yang sebelumnya operator negatif
                        if (negCount == 1)
                        {
                            tempElmt = new Elemen <string>((tempElmt.GetItem2() * -1).ToString());
                        }
                    }
                    else        // Penanganan Operator
                    {
                        if (tempElmt.GetItem1() == "-" && negCount < 1)
                        {
                            negCount++;
                            continue;
                        }
                        else if (tempElmt.GetItem1() == "akar")
                        {
                        }
                        else
                        {
                            throw (new ExpressionSyntaxErrorException("Syntax Error : Consecutive Operators"));
                        }
                    }
                    break;

                // 2.2  State 2 menandakan state untuk membaca operator
                //      State 2 cenderung lebih sederhana karena hanya tinggal membaca operator
                //      Tidak dilakukan pembacaan terminal karena sudah ada prekondisi dari GUI
                //      tidak ada dua terminal yang berurutan
                //      Pada kasus ini hanya me-set state kembali menjadi 1 dan mereset negCount
                case 2:
                    if (tempElmt.GetItem1() != "#")
                    {
                        state    = 1;
                        negCount = 0;
                    }
                    break;
                }
                //  3. Elemen yang di dequeue disimpan sementara dalam queue temporary
                tempQueue.Enqueue(tempElmt);
            }

            //  4. Dilakukan pengopian kembali queue yang sudah benar dari temporary ke InfixQueue
            while (tempQueue.Count != 0)
            {
                tempElmt = tempQueue.Dequeue();
                this.expressionInfixQueue.Enqueue(tempElmt);
            }

            state = 0;
        }