0 ratings0% found this document useful (0 votes)
71 views30 pagesMy - Calculator Report
This desktop application is a Scientific Calculator implemented in Java using Swing and AWT. It serves as an educational project covering essential Java concepts, including the Math class, Classes and Objects, Functions, Loops, Conditionals, and Variables.
Uploaded by
04 Pandey Abhishek Nath RoyCopyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
0 ratings0% found this document useful (0 votes)
71 views30 pagesMy - Calculator Report
This desktop application is a Scientific Calculator implemented in Java using Swing and AWT. It serves as an educational project covering essential Java concepts, including the Math class, Classes and Objects, Functions, Loops, Conditionals, and Variables.
Uploaded by
04 Pandey Abhishek Nath RoyCopyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
You are on page 1/ 30
1. INTRODUCTION
Hey, curious minds, imagine a magical tool that helps us play with numbers and unleash the
secrets of math in a super cool way, Well, that’s exactly what our project is all about ~ “A
Graphical User Interface (GU1)-based Scientific Calculator!"
You must be wondering, “What's a GUI-based Scientific Calculator? Well, it is just an
interactive calculator which can do way more than just bas
math wizard in our pocket.
Picture this: we can not only perform addition, subtraction, multiplication and division but
also incorporates advanced functionalities such as square root, exponentiation, factorial and
trigonometric functions.
So, get ready to embark on a math adventure with our “GULbased Scientific Calculator”
Whether we are a math wizard or just starting to explore the world of numbers, this project is
here to make math a blast! Let’s dive in and discover the magic of numbers together!
mathematics; it’s like having a
2. OBJECTIVE
‘The objective of the project is to create a fully functional scientific calculator equipped with a
user-friendly GUL This involves implementing a calculator that not only performs basic
arithmetic operations like addition, subtraction, multiplication and division but also
incorporates advanced functionalities such as square root, exponentiation, factorial and
trigonometric functions. ‘The emphasis is on providing a seamless or enjoyable user
experience through an intuitive interface, making mathematical calculations accessible and
straightforward for users.
TECHNOLOGY USED
v Java
% Portability — Java is platform independent so that allows the
to run on various operating systems without modification
% Object-Oriented Approach ~ Its object-oriented nature facilitates modular and
organized code, making it easier to manage complex functionalities.
¥ Swing and AWT
Graphical User Interface (GUI) — Both provides powerful GUI components for
java applications, We chose these to libraries to design the caleulator’s user
interface with panels, buttons, and text fields.
% Look and Feel ~ They offer customizable look and feel, ensuring a consistent
appearance across different platforms
Layout Management — Layout managers in Swing and AWT simplify the
arrangement of components in the GUI We utilize GridLayout for the button
panel, ensuring a neat and organized layout.
ientific calculator
Y Math Library ¢ Mathematical Operations ~ Java’s Math library is erucial for performing,
complex mathematical operations. It provides functions for basic arithmetic,
exponentiation, logarithms, and trigonometric calculations. It is essential for our
project.
% Accuracy ~It ensures accurate results in calculations as the reliability plays a
vital role in our scientific calculator.
+ Support for constants like pi or e.
v Utility Library
* Custom Functionality — It provides custom funetionalities that will be needed for
infix to postfix operations or stack for operator precedence.
Code Reusability ~ It promotes code reusability by encapsulating common
functions that may be utilized in various parts of the calculator. This modular
approach simplifies development, debugging, and maintenanee
% Enhanced User Experience ~ It may include features such as error handling,
input validation, or specialized mathematical funetions. These additions
contribute to a seamless user experience.
Y Sublime Text — A light weight text editor used for developing the project.
4. DESIGN PRINCIPLES AND COMPONENTS
GUI Design Principle: MVC Architecture
In designing the scientific calculator, we can adhere to the Model-View-Controller (MVC)
architectural patter, This separation helps to organize our code in a way that makes it more
modular and easier to maintain,
Model(M)
‘The model represents the core functionality and data of the calculator. It encapsulates the
logic for mathematical operations, conversion between infix and postfix notations, and the
evaluation of expressions,
View(V)
‘The view is responsible for displaying the user interface. In our GUI-based seientific
calculator, it includes components like buttons, text fields, and labels. The view
communicates user actions to the controller and updates the display based on the model's
state,
Controller(C)
‘The controller acts as an intermediary, handling user input from the view and updating the
model accordingly. It also receives updates from the model and reflects changes in the view.
‘This separation of concerns enhances the flexibility and maintainability of the code.
GUI Design Components: Panels, Buttons, and Layout Managers
Our Graphical User Interface (GUD is designed to be user-friendly and visually appealing
‘The various components are as follows: -
Frame Structure - The main calculator window is structured using a./!"rame. This provides
overall frame of the calculator application.
Text Panel ~ Utilizing a.JPane!, we create a designated area to display the mathematical expression and results. This panel includes a /L.abel for the expression and A JTevt!"ield for
the user to input and view calculations,
Another /Pane! is used to organize and layout the calculator buttons, We
employ a BevelBorder to enhance the visual appeal. Gridl.ayout is chosen as the layout
manager for the button panel, ensuring a neat arrangement of buttons in rows and columns.
Buitons —.JButton is used to create buttons. They are essential components for user
interaction. Each button is associated with a specific digit (0-9), operator (+, -,*,/) or
mathematical function (sqrt, sin, cos, tan).
Actiont. isteners— Each button is equipped with an ActionListener to respond to user clicks
steners trigger actions in the controller, initiating the corresponding calculations or
Button Pane!
These
updates.
ALGORITHMS (INCLUDES OPERATOR PRECENDENCE)
‘The conversion from infix to postfix is a fundamental algorithm employed in mathematical
computations, particularly in the evaluation of expressions. This algorithm is crucial for
simplifying complex mathematical expressions and enabling efficient calculation within a
calculator application.
Y Importance in Mathematical Computations:
% Operator Precedence Handling - The algorithm ensures correct handling of
operator precedence, crucial for accurate mathematical calculations. It establishes a
clear order of operations, preventing ambiguity in expressions
% Optimized Evaluation - Postfix notation eliminates the need for parentheses and
reduces the complexity of expression evaluation. This results ina more
straightforward and optimized process for calculating mathematical expressions.
% Stack-Based Evaluation - The algorithm utilizes a stack data structure to convert
infix expressions into postfix. This stack-based approach simplifies the parsing and
evaluation of expressions, providing an organized and efficient method for
calculation.
% Compatibility with Calculator Logic - For a calculator application, converting infix
to postfix aligns with the logic of parsing user-input mathematical expressions. It
allows the calculator to process expres stematically, ensuring accurate
results
Y Key Steps in the Algorithm:
* Operand Handling - Operands (numbers and constants) are added directly to the
output, preserving their order.
% Operator Handling - Operators are pushed onto a stack with consideration for their
precedence. When a lower precedence operator is encountered, higher precedence
operators on the stack are popped and added to the output until the stack is
appropriately ordered.
Parenthesis Handling - Parenth
s are crucial for grouping operations. The
algorithm manages parentheses, ensuring that expressions within parentheses are appropriately prioritized,
% Output Formation - The final postfix expression is formed by combining the
operators and operands in the correct order.
Y Benefits of Postfix Notation:
* Simplicity in Evaluation - Postfix expressions are inherently simpler to evaluate as
they don't require complex parsing rules associated with infix expressions. This,
simplicity contributes to the efficiency of mathematical computations.
# Reduction of Ambiguity « The postfix notation eliminates the need for explicit
parentheses to indicate the order of operations. This reduces ambigui
expressions, making them easier to understand and evaluate.
By employing the infix to postfix conversion algorithm, our calculator ensures a streamlined
and efficient process for handling mathematical expressions, aligning with the expectations of
users engaged in scientific calculations. 6. CODING
import javax.swing.*,
import javax.swing, border BevelBorder,
import java.awt.*;
import java.awtevent.*,
import java.util.*;
class Calculator {
JFrame fimCalculator,
> token-new ArrayList=String>(;
boolean num=false:
boolean dot=false;
public static void main(String[] args) {
EventQueue invokeLater(new Runnable() {
public void run() {
ty ft
Calculator window = new Calculator();
window fimCalculator.set Visible(true);
} catch (Exception ) {
e.printStackTrace();
3
3
Ds
3
Caleulator() {
initialize();
3
int precedence(String x)
t
int p=10,
switch(x) {
case "+"
pals
break; break;
case "x"
p-3;
break;
ease "":
po
break;
case"
p-6;
break;
case "!":
po?
break;
3
return p;
3
operator checking
private boolean isoperator(String x)
t
if{s.equals("+") || xequals("-") || x.equals("'x") || x.equals("/") |) x.equals("'sqrt")
|| xequals("™") | xequals("") || xequals("sin") || x.equals("cos") |) x.equals("tan") |
x.equals("In") | x.equals("log"))
return true;
else
retum false:
3
private String infix Topostfis()
t
StackString> s-new Stacl
String y;
int flag,
String p
token.add(")");
s.push("(");
for(String i: token) {
iffi.equals("(")){
s.push(
jelse if(i.equals(")"))f
ys-pop0:
while(!y.equals("("))
t
String>Q: poptye"";
Ys-pop()s
else Peaeaiel
y-s.pop0);
flag-0:
iffisoperator(y) && precedence(y)>precedence(i)){
poptye":
flag=1;
3
if{flag--0)
s.push(y);
s.push(i);
yelse{
poptit'.":
3
3
while(!s.empty() {
Y=s.pop();
if(ty.equals("(") && !y.equals(")")) {
pesyt""5
3
3
return p;
actorial method
private double factorial(double y) {
double fact=1:
iffy--0 || y= ¢
fact=1;
yelse
3
return fact;
for actual calculation with binary operators
private double calculate(double x,double y.String e)
t double res=0;
switch(e)
t
cer
case "!":
case"
res~ Math, pow(sy);
break;
default :
res= 0
3
return res;
‘calculation with unary operators
private double calculate(double y.String c) {
double res=0;
switeh(e) {
case "log"
res = Math logl0(y);
break;
case "sin":
res~ Math sin(y),
break;
case "cos"
res = Math.cos(y);
break;
case "tan":
res
break;
case "In":
res= Math log(y):
break;
case "sqrt":
fath.tan(y); res= Math sqrt(y);
break;
case "!":
res-factorial(y);
break;
3
return res;
3
private double Eval(String p)
t
String tokensf] =p split(”,"),
ArrayList token2=new ArrayList();
for(int i=0; i s=new Stack();
double x.y;
for(String i:token2) {
ifisoperator(i)){
//if itis unary operator or function
if(equals("sin") ||iequals(""cos") |i.equals("tan")
i.equals("log") || iequals("In") | iequals("sqrt") | iequals("!")) {
yos.pop():
s.push(calculate(y.i));
jelse {
/ifor binary operators
y>s-pop():
X=s.pop0;
s push(caleulate(x,y.i));
3
jelseg
iffi.equals("pi"))
s.push(Math. PI),
else if(i-equals("e"))
s.push(Math. E);
else
s.push(Double.valueOf{i)): 3
¥
double res=1;
while(!s.emptyQ) {
res*=s.pop();
3
retum res; //final result
//actual combined method for calculation
private void caleulateMain() {
String tokens[]=expression split(",");
for(int i=0; i 1) ¢
String newString = s.substring(0,s.length(-1);
textField setText(newString),
iffexpression.charAt(expression.length()-1)—"') £
dot=false;
3
if\expression.charAt(expression.Jength()-1
expression =
mn.Jength()-2);
yelse {
expression =
expression substring(0,espression length()-1);
3
yelse {
textField.setText("0");
wt
expression substring(0,expre
expression=
3
D:
button2.setFont(new Font("Calibri Light", Font. PLAIN, 14)):
butttonPanel.add(button2);
‘button for constant pi
Button button3 = new JButton(""1
");
button3.setFont(new Font("Calibri Light", Font.PLAIN, 17));
button3.addActionListener(new ActionListener {
public void actionPerformed(ActionE vent e) {
if{! "0" equals(textField.getText())) {
textField setText(textField get Text() + Character-toString((char)960));
yelse {
textField set Text(Charaeter.toString((char)960));
}
expression += "J
num-false:
dot=false: D:
butttonPanel.add(button3):
‘button for x
Button buttond = new
JButton("Xy