annexure-I

 CREATE A CALCULATOR USING A JAVA PROGRAM 

1.0   Aims/Benefits of the micro project

Java technology is widely used for web application development. Based on the object-
oriented concepts and core Java concepts, this course will equip the students with the
required knowledge and skill of the object-oriented programming approach needed for the
development of robust, powerful web applications. Through this course, students will get
hands-on experience with GUI Technologies viz. AWT and Swings, event handling
mechanisms, and network programming. The course also gives coverage to various web
application aspects like Database Interaction, server-side components, and servlets.

2.0   Course outcome addressed.

a) Create a calculator app using java eclipse 
b) Use a calculator app to perform different operations like addition, division, subtraction,
multiplication, and more.

3.0 Proposed methodology

1. Focused on the selection of an appropriate topic for the micro-project. 

2. Select the topic i.e. Calculator using Java program. 
3. Brief study as well as a survey on our topic. 
4. Gather all information based on the topic of the micro project. 
5. Analysis and study of our topic in detail. 
6. Following all the above methodologies we successfully completed our microproject.
 annexure-II

Micro-Project Report

 CREATE A CALCULATOR USING A JAVA PROGRAM 

1.0 Brief Introduction/Rationale

The first solid-state electronic calculator was made in the early 1960s. Pocket-sized gadgets
became available in the 1970s, particularly after the Intel 4004, the first microprocessor, was
designed by Intel for the Japanese calculator company Busicom. They later became utilized
generally within the petroleum industry (oil and gas). Modern electronic calculators vary
from affordable, give-away, credit-card-sized models to sturdy desktop models with built-in
printers. They became famous in the mid-1970s as the incorporation of integrated circuits
decreased their size and cost. By the end of that decade, prices had fallen to the point where a
basic calculator was affordable to most and they became familiar in schools. In addition to
general-purpose calculators, there are those created for specific markets. For example, there
are scientific calculators which contain trigonometric and statistical calculations. Some
calculators even have the capacity to do computer algebra. Graphing calculators can be used
to graph functions defined on the real line or higher-dimensional Euclidean space. As of
2016, basic calculators cost little, but scientific and graphing models tend to cost more.

Uses of the Calculator : 

 A calculator is a device that executes arithmetic operations on numbers. The easiest

calculators can do only addition, subtraction, multiplication, and division. More sophisticated
calculators can handle exponential operations, roots, logarithms, trigonometric functions, and
hyperbolic functions. Internally, some calculators even accomplish all of these functions by
repeated processes of addition. Most calculators these days need electricity to operate.
Portable, battery-powered calculators are popular with engineers and engineering students.
Before 1970, a more elementary form of calculator, the slide rule, was generally utilized. It
consisted of a slat of wood, called the slide, that could be moved in and out of a reinforced
pair of slats. Both the slide and the outer pair of slats had calibrated numerical scales. A
movable, transparent sleeve called the cursor was used to align numerals on the scales. The
slide rule did not need any source of power, but its precision was restrained, and it was
required to climb a learning curve to become proficient with it.

One of the most primal calculators, the abacus is still utilized in some parts of the Far East.
The abacus uses groups of beads to indicate numbers. Like the slide rule, the abacus requires
no source of power. The beads are positioned in several parallel rows and can be rolled up
and down to denote arithmetic operations. It is said that a skilled abacus user can do some
calculations just as fast as a person equipped with a battery-powered calculator. As
calculators became more advanced during the 1970s, they became capable to make
computations involving variables (unknowns). These were the first personal computers.
Today's personal computers can still accomplish such operations, and most are delivered with
a virtual calculator program that actually looks, on screen, like a handheld calculator. The
buttons are actuated by pointing and clicking. Electronic calculators contain a keyboard with
buttons for digits and arithmetical operations; some even contain "00" and "000" buttons to
make larger or smaller numbers more comfortable to enter. Most basic calculators assign only
one digit or operation on each button; however, in more specific calculators, a button can
perform multi-function working with key combinations. Display output Calculators usually
have liquid-crystal displays (LCD) as output in place of historical light-emitting diode (LED)
displays and vacuum fluorescent displays (VFD); details are supplied in the section Technical
improvements. 

Program Code :
import java.awt.*;
import java.awt.event.*;

public class MyCalculator extends Frame

{
public boolean setClear=true;
double number, memValue;
char op;
String digitButtonText[] = {"7", "8", "9", "4", "5", "6", "1", "2", "3", "0", "+/-", "." };
String operatorButtonText[] = {"/", "sqrt", "*", "%", "-", "1/X", "+", "=" };
String memoryButtonText[] = {"MC", "MR", "MS", "M+" };
String specialButtonText[] = {"Backspc", "C", "CE" };

MyDigitButton digitButton[]=new MyDigitButton[digitButtonText.length];

MyOperatorButton operatorButton[]=new MyOperatorButton[operatorButtonText.length];
MyMemoryButton memoryButton[]=new MyMemoryButton[memoryButtonText.length];
MySpecialButton specialButton[]=new MySpecialButton[specialButtonText.length];

Label displayLabel=new Label("0",Label.RIGHT);

Label memLabel=new Label(" ",Label.RIGHT);

final int FRAME_WIDTH=325,FRAME_HEIGHT=325;

final int HEIGHT=30, WIDTH=30, H_SPACE=10,V_SPACE=10;
final int TOPX=30, TOPY=50;

MyCalculator(String frameText)
{
super(frameText);

int tempX=TOPX, y=TOPY;

displayLabel.setBounds(tempX,y,240,HEIGHT);
displayLabel.setBackground(Color.BLUE);
displayLabel.setForeground(Color.WHITE);
add(displayLabel);

memLabel.setBounds(TOPX, TOPY+HEIGHT+ V_SPACE,WIDTH, HEIGHT);

add(memLabel);

tempX=TOPX;
y=TOPY+2*(HEIGHT+V_SPACE);
for(int i=0; i<memoryButton.length; i++)
{
memoryButton[i]=new MyMemoryButton(tempX,y,WIDTH,HEIGHT,memoryButtonText[i], this);
memoryButton[i].setForeground(Color.RED);
y+=HEIGHT+V_SPACE;
}

tempX=TOPX+1*(WIDTH+H_SPACE); y=TOPY+1*(HEIGHT+V_SPACE);
for(int i=0;i<specialButton.length;i++)
{
specialButton[i]=new MySpecialButton(tempX,y,WIDTH*2,HEIGHT,specialButtonText[i], this);
specialButton[i].setForeground(Color.RED);
tempX=tempX+2*WIDTH+H_SPACE;
}

int digitX=TOPX+WIDTH+H_SPACE;
int digitY=TOPY+2*(HEIGHT+V_SPACE);
tempX=digitX; y=digitY;
for(int i=0;i<digitButton.length;i++)
{
digitButton[i]=new MyDigitButton(tempX,y,WIDTH,HEIGHT,digitButtonText[i], this);
digitButton[i].setForeground(Color.BLUE);
tempX+=WIDTH+H_SPACE;
if((i+1)%3==0){tempX=digitX; y+=HEIGHT+V_SPACE;}
}

int opsX=digitX+2*(WIDTH+H_SPACE)+H_SPACE;
int opsY=digitY;
tempX=opsX; y=opsY;
for(int i=0;i<operatorButton.length;i++)
{
tempX+=WIDTH+H_SPACE;
operatorButton[i]=new MyOperatorButton(tempX,y,WIDTH,HEIGHT,operatorButtonText[i], this);

operatorButton[i].setForeground(Color.RED);
if((i+1)%2==0){tempX=opsX; y+=HEIGHT+V_SPACE;}
}

addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent ev)
{System.exit(0);}
});
setLayout(null);
setSize(FRAME_WIDTH,FRAME_HEIGHT);
setVisible(true);
}

static String getFormattedText(double temp)

{
String resText=""+temp;
if(resText.lastIndexOf(".0")>0)
resText=resText.substring(0,resText.length()-2);
return resText;
}
public static void main(String []args)
{
new MyCalculator("Calculator - JavaTpoint");
}
}
class MyDigitButton extends Button implements ActionListener
{
MyCalculator cl;

MyDigitButton(int x,int y, int width,int height,String cap, MyCalculator clc)

{
super(cap);
setBounds(x,y,width,height);
this.cl=clc;
this.cl.add(this);
addActionListener(this);
}
static boolean isInString(String s, char ch)
{
for(int i=0; i<s.length();i++) if(s.charAt(i)==ch) return true;
return false;
}
public void actionPerformed(ActionEvent ev)
{
String tempText=((MyDigitButton)ev.getSource()).getLabel();
if(tempText.equals("."))
{
if(cl.setClear)

{cl.displayLabel.setText("0.");cl.setClear=false;}
else if(!isInString(cl.displayLabel.getText(),'.'))
cl.displayLabel.setText(cl.displayLabel.getText()+".");
return;
}
int index=0;
try{
index=Integer.parseInt(tempText);
}catch(NumberFormatException e){return;}

if (index==0 && cl.displayLabel.getText().equals("0")) return;

if(cl.setClear)
{cl.displayLabel.setText(""+index);cl.setClear=false;}
else
cl.displayLabel.setText(cl.displayLabel.getText()+index);
}
}

class MyOperatorButton extends Button implements ActionListener

{
MyCalculator cl;

MyOperatorButton(int x,int y, int width,int height,String cap, MyCalculator clc)

{
super(cap);
setBounds(x,y,width,height);
this.cl=clc;
this.cl.add(this);
addActionListener(this);
}
public void actionPerformed(ActionEvent ev)
{
String opText=((MyOperatorButton)ev.getSource()).getLabel();

cl.setClear=true;
double temp=Double.parseDouble(cl.displayLabel.getText());

if(opText.equals("1/x"))
{
try
{double tempd=1/(double)temp;
cl.displayLabel.setText(MyCalculator.getFormattedText(tempd));}
catch(ArithmeticException excp)
{cl.displayLabel.setText("Divide by 0.");}
return;
}
if(opText.equals("sqrt"))
{
try
{double tempd=Math.sqrt(temp);
cl.displayLabel.setText(MyCalculator.getFormattedText(tempd));}

catch(ArithmeticException excp)
{cl.displayLabel.setText("Divide by 0.");}
return;
}
if(!opText.equals("="))
{
cl.number=temp;
cl.op=opText.charAt(0);
return;
}
switch(cl.op)
{
case '+':
temp+=cl.number;break;
case '-':
temp=cl.number-temp;break;
case '*':
temp*=cl.number;break;
case '%':
try{temp=cl.number%temp;}
catch(ArithmeticException excp)
{cl.displayLabel.setText("Divide by 0."); return;}
break;
case '/':
try{temp=cl.number/temp;}
catch(ArithmeticException excp)
{cl.displayLabel.setText("Divide by 0."); return;}
break;
}
cl.displayLabel.setText(MyCalculator.getFormattedText(temp));
}
}
class MyMemoryButton extends Button implements ActionListener
{
MyCalculator cl;

MyMemoryButton(int x,int y, int width,int height,String cap, MyCalculator clc)

{
super(cap);
setBounds(x,y,width,height);
this.cl=clc;
this.cl.add(this);
addActionListener(this);
}
public void actionPerformed(ActionEvent ev)
{
char memop=((MyMemoryButton)ev.getSource()).getLabel().charAt(1);

cl.setClear=true;
double temp=Double.parseDouble(cl.displayLabel.getText());

switch(memop)
{
case 'C':
cl.memLabel.setText(" ");cl.memValue=0.0;break;
case 'R':
cl.displayLabel.setText(MyCalculator.getFormattedText(cl.memValue));break;
case 'S':
cl.memValue=0.0;
case '+':
cl.memValue+=Double.parseDouble(cl.displayLabel.getText());
if(cl.displayLabel.getText().equals("0") || cl.displayLabel.getText().equals("0.0") )
cl.memLabel.setText(" ");
else
cl.memLabel.setText("M");
break;
}
}
}
class MySpecialButton extends Button implements ActionListener
{
MyCalculator cl;
MySpecialButton(int x,int y, int width,int height,String cap, MyCalculator clc)
{
super(cap);
setBounds(x,y,width,height);
this.cl=clc;
this.cl.add(this);
addActionListener(this);
}
static String backSpace(String s)
{
String Res="";
for(int i=0; i<s.length()-1; i++) Res+=s.charAt(i);
return Res;
}
public void actionPerformed(ActionEvent ev)
{
String opText=((MySpecialButton)ev.getSource()).getLabel();

if(opText.equals("Backspc"))
{
String tempText=backSpace(cl.displayLabel.getText());
if(tempText.equals(""))
cl.displayLabel.setText("0");
else
cl.displayLabel.setText(tempText);
return;
}
if(opText.equals("C"))
{
cl.number=0.0; cl.op=' '; cl.memValue=0.0;
cl.memLabel.setText(" ");
}
cl.displayLabel.setText("0");cl.setClear=true;
}
}

Outputs of Micro-Project :
3.0 Skill Developed

 We learn how to make the project of menu-driven programming in Java 

 We learn how to make the coding and program. 
 We learn how to edit the program and how to do the presentation for the project. 
 We learn how to make the report for the project. 
 These are all things we learn from the project.

4.0 Application of this Micro-Project:-

To perform basic mathematical operations using this simple calculator