Aplikasi menghitung matematika dengan c++

1. Program untuk memperkirakan nilai Integral dari fungsi yang diberikan
menggunakan aturan kuadrat Gaussian di C ++ Programming
# include <iostream.h>
# include <stdlib.h>
# include <string.h>
# include <stdio.h>
# include <conio.h>
# include <math.h>
constint max_size=13;
int n=0;
int top=-1;
longdouble a=-1;
longdouble b=1;
longdouble two_point_result=0;
longdouble three_point_result=0;
char Fx[100]={NULL};
char Stack[30][30]={NULL};
char Postfix_expression[30][30]={NULL};
/*************************************************************************//
*************************************************************************///
------------------------ Funcion Prototypes -------------------------
///*************************************************************************
//*************************************************************************/
void push(constchar *);
void convert_ie_to_pe(constchar *);
constchar* pop( );
constlongdouble evaluate_postfix_expression(constlongdouble);
void show_screen( );
void clear_screen( );
void get_input( );
void change_limits( );
void apply_gaussian_quadrature_rule( );
void show_result( );
/*************************************************************************//
*************************************************************************///
------------------------------ main( ) ------------------------------
///*************************************************************************
//*************************************************************************/
int main( )
{

clrscr( );
textmode(C4350);
show_screen( );
get_input( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//
*************************************************************************///
------------------------ Funcion Definitions ------------------------
///*************************************************************************
//*************************************************************************/
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
/void show_screen( )
{
cprintf("n******************************************************************
**************");
cprintf("***************************- -
**************************");
cprintf("*--------------------------- ");
textbackground(1);
cprintf("Integrasi numerik ");
textbackground(8);
cprintf(" --------------------------*");
cprintf("*-*************************- -
************************-*");
cprintf("*-
***************************************************************************
*-*");
for(int count=0;count<42;count++)
cprintf("*-* *-*");
gotoxy(1,46);
cprintf("*-
***************************************************************************
*-*");
cprintf("*------------------------------------------------------------------------------*");

cprintf("********************************************************************
************");
gotoxy(1,2);
}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
/void clear_screen( )
{
{
gotoxy(5,8+count);
cout<<" ";
}
gotoxy(1,2);
}
/*************************************************************************//
/-------------------------- push(const char*) ------------------------
///*************************************************************************
/void push(constchar* Operand)
{
if(top==(max_size-1))
{
cout<<"Error : Stack is full."<<endl;
cout<<"n Press any key to exit.";
getch( );
exit(0);
}
else
{
top++;
strcpy(Stack[top],Operand);
}
}
/*************************************************************************//
/------------------------------ pop( ) -------------------------------
///*************************************************************************
/constchar* pop( )
{

char Operand[40]={NULL};
if(top==-1)
{
cout<<"Error : Stack is empty."<<endl;
getch( );
exit(0);
}
else
{
strcpy(Operand,Stack[top]);
strset(Stack[top],NULL);
top--;
}
return Operand;
}
/*************************************************************************//
/-------------------- convert_ie_to_pe(const char*) ------------------
///*************************************************************************
/void convert_ie_to_pe(constchar* Expression)
{
char Infix_expression[100]={NULL};
char Symbol_scanned[30]={NULL};
push("(");
strcpy(Infix_expression,Expression);
strcat(Infix_expression,"+0)");
int flag=0;
int count_1=0;
int count_2=0;
int equation_length=strlen(Infix_expression);
if(Infix_expression[0]=='(')
flag=1;
do
{
strset(Symbol_scanned,NULL);
if(flag==0)
{
int count_3=0;

do
{
Symbol_scanned[count_3]=Infix_expression[count_1];
count_1++;
count_3++;
}
while(count_1<=equation_length &&
Infix_expression[count_1]!='(' &&
Infix_expression[count_1]!='+' &&
Infix_expression[count_1]!='-' &&
Infix_expression[count_1]!='*' &&
Infix_expression[count_1]!='/' &&
Infix_expression[count_1]!='^' &&
Infix_expression[count_1]!=')');
flag=1;
}
elseif(flag==1)
{
Symbol_scanned[0]=Infix_expression[count_1];
count_1++;
if(Infix_expression[count_1]!='(' &&
Infix_expression[count_1]!=')')
flag=0;
if(Infix_expression[count_1-1]=='(' &&
(Infix_expression[count_1]=='-' ||
Infix_expression[count_1]=='+'))
flag=0;
}
if(strcmp(Symbol_scanned,"(")==0)
push("(");
elseif(strcmp(Symbol_scanned,")")==0)
{
while(strcmp(Stack[top],"(")!=0)
{
strcpy(Postfix_expression[count_2],pop( ));

count_2++;
}
pop( );
}
elseif(strcmp(Symbol_scanned,"^")==0 ||
strcmp(Symbol_scanned,"+")==0 ||
strcmp(Symbol_scanned,"-")==0 ||
strcmp(Symbol_scanned,"*")==0 ||
strcmp(Symbol_scanned,"/")==0)
{
if(strcmp(Symbol_scanned,"^")==0)
{ }
elseif(strcmp(Symbol_scanned,"*")==0 ||
{
while(strcmp(Stack[top],"^")==0 ||
strcmp(Stack[top],"*")==0 ||
strcmp(Stack[top],"/")==0)
{
count_2++;
}
}
elseif(strcmp(Symbol_scanned,"+")==0 ||
strcmp(Symbol_scanned,"-")==0)
{
{
count_2++;
}
}
push(Symbol_scanned);
}
else
{
strcat(Postfix_expression[count_2],Symbol_scanned);
count_2++;
}
}
while(strcmp(Stack[top],NULL)!=0);

strcat(Postfix_expression[count_2],"=");
count_2++;
}
/*************************************************************************//
/---------- evaluate_postfix_expression(const long double) -----------
///*************************************************************************
/constlongdouble evaluate_postfix_expression(constlongdouble x)
{
longdouble function_value=0;
int count_1=-1;
do
{
count_1++;
strcpy(Symbol_scanned,Postfix_expression[count_1]);
if(strcmp(Symbol_scanned,"^")==0 ||
strcmp(Symbol_scanned,"/")==0 ||
{
char Result[30]={NULL};
char Operand[2][30]={NULL};
strcpy(Operand[0],pop( ));
longdouble operand[2]={0};
longdouble result=0;
char *endptr;
for(int count_2=0;count_2<2;count_2++)
{
int flag=0;
if(Operand[count_2][0]=='-')
{
int length=strlen(Operand[count_2]);
for(int count_3=0;count_3<(length-1);count_3++)

Operand[count_2][count_3]=Operand[count_2][(count_3+1)];
Operand[count_2][count_3]=NULL;
flag=1;
}
if(strcmp(Operand[count_2],"x")==0)
operand[count_2]=x;
elseif(strcmp(Operand[count_2],"e")==0)
operand[count_2]=2.718282;
elseif(strcmp(Operand[count_2],"sinx")==0)
operand[count_2]=sinl(x);
elseif(strcmp(Operand[count_2],"cosx")==0)
operand[count_2]=cosl(x);
elseif(strcmp(Operand[count_2],"tanx")==0)
operand[count_2]=tanl(x);
elseif(strcmp(Operand[count_2],"lnx")==0)
operand[count_2]=logl(x);
elseif(strcmp(Operand[count_2],"logx")==0)
operand[count_2]=log10l(x);
else
operand[count_2]=strtod(Operand[count_2],&endptr);
if(flag)
operand[count_2]*=-1;
}
switch(Symbol_scanned[0])
{
case'^' : result=powl(operand[1],operand[0]);
break;
case'*' : result=operand[1]*operand[0];
break;
case'/' : result=operand[1]/operand[0];
break;
case'+' : result=operand[1]+operand[0];
break;
case'-' : result=operand[1]-operand[0];

break;
}
gcvt(result,25,Result);
push(Result);
}
elseif(strcmp(Symbol_scanned,"=")!=0)
}
while(strcmp(Symbol_scanned,"=")!=0);
char Function_value[30]={NULL};
char *endptr;
strcpy(Function_value,pop( ));
function_value=strtod(Function_value,&endptr);
return function_value;
}
/*************************************************************************//
/----------------------------- get_input( ) --------------------------
///*************************************************************************
/void get_input( )
{
clear_screen( );
gotoxy(6,10);
cout<<"Non-Linear Function :";
gotoxy(6,11);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(6,37);
cout<<"Note : Write the function with proper Braces ( ) e.g; 2x+3 as (2*x)+3";
gotoxy(6,40);
cout<<"Available Operators : ^ (raised to power) , * , / , + , -";
gotoxy(6,42);
cout<<"Available Operands : x , e , sinx , cosx , tanx , lnx , logx ,";
gotoxy(6,44);
cout<<" n = any number";
gotoxy(6,14);
cout<<"Enter the Function : f(x) = ";

cin>>Fx;
convert_ie_to_pe(Fx);
}
/*************************************************************************//
/----------------- apply_gaussian_quadrature_rule( ) -----------------
///*************************************************************************
/void apply_gaussian_quadrature_rule( )
{
longdouble temp_1=0;
temp_1=evaluate_postfix_expression((-sqrtl(0.6)));
temp_1*=(0.555555556);
temp_2=evaluate_postfix_expression(0);
temp_2*=(0.888888889);
temp_3=evaluate_postfix_expression(sqrtl(0.6));
temp_3*=(0.555555556);
three_point_result=(temp_1+temp_2+temp_3);
temp_1=0;
temp_2=0;
temp_1=evaluate_postfix_expression((-1/sqrtl(3)));
temp_2=evaluate_postfix_expression((1/sqrtl(3)));
two_point_result=(temp_1+temp_2);
}
/*************************************************************************//
/---------------------------- show_result( ) -------------------------
///*************************************************************************
/void show_result( )
{
clear_screen( );
gotoxy(6,9);
cout<<"Gaussian Quadrature Rule:";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";

gotoxy(24,12);
cout<<" 1ô";
gotoxy(6,13);
cout<<"Two Point Rule: ³f(x)dx ÷ f(-1/û3)+f(1/û3)";
gotoxy(24,14);
cout<<"-1õ";
gotoxy(24,16);
cout<<" 1ô";
gotoxy(6,17);
cout<<"Three Point Rule: ³f(x)dx ÷ (5/9)f(-û(3/5))+(8/9)f(0)+(5/9)f(û(3/5))";
gotoxy(24,18);
cout<<"-1õ";
apply_gaussian_quadrature_rule( );
gotoxy(6,22);
cout<<" 1ô";
gotoxy(6,24);
cout<<" -1õ";
gotoxy(6,23);
cout<<"Estimation of ³f(x)dx :";
gotoxy(6,25);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(8,27);
cout<<"Estimated Integral Value (using 2-Point Rule) = "<<two_point_result;
gotoxy(8,29);
cout<<"Estimated Integral Value (using 3-Point Rule) = "<<three_point_result;
gotoxy(1,2);
}
2. Program untuk memperkirakan nilai Integral dari fungsi di poin yang diberikan dari
data yang diberikan dengan Metode Romberg di C ++ Programming
# include <stdio.h>
# include <conio.h>
# include <math.h>

int n=0;
int top=-1;
longdouble h=0;
longdouble a=0;
longdouble b=0;
longdouble ri[max_size][max_size]={0};
longdouble xn[max_size]={0};
longdouble fx[max_size]={0};
/*************************************************************************//
*************************************************************************///
///*************************************************************************
//*************************************************************************/
constchar* pop( );
void get_input( );
void apply_trapezoidal_rule( );
void apply_romberg_method( );
/*************************************************************************//
*************************************************************************///
------------------------------ main( ) ------------------------------
///*************************************************************************
//*************************************************************************/
int main( )
{
clrscr( );
textmode(C4350);
show_screen( );
get_input( );

apply_trapezoidal_rule( );
apply_romberg_method( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//
*************************************************************************///
///*************************************************************************
//*************************************************************************/
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{
cprintf("n******************************************************************
**************");
cprintf("****************************- -
***************************");
cprintf("*---------------------------- ");
textbackground(1);
cprintf(" Romberg Integration ");
textbackground(8);
cprintf(" ---------------------------*");
cprintf("*-**************************- -
*************************-*");
cprintf("*-
***************************************************************************
*-*");
cprintf("*-* *-*");
gotoxy(1,46);
cprintf("*-
***************************************************************************
*-*");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);

}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
{
gotoxy(5,8+count);
cout<<" ";
}
gotoxy(1,2);
}
/*************************************************************************//
/-------------------------- push(const char*) ------------------------
///*************************************************************************
{
{
getch( );
exit(0);
}
else
{
top++;
}
}
/*************************************************************************//
/------------------------------ pop( ) -------------------------------
///*************************************************************************
/constchar* pop( )
{
if(top==-1)
{

getch( );
exit(0);
}
else
{
top--;
}
return Operand;
}
/*************************************************************************//
///*************************************************************************
{
push("(");
int flag=0;
int count_1=0;
int count_2=0;
flag=1;
do
{
if(flag==0)
{
int count_3=0;
do
{
count_1++;

count_3++;
}
flag=1;
}
elseif(flag==1)
{
count_1++;
flag=0;
flag=0;
}
push("(");
{
{
count_2++;
}
pop( );
}

{
{ }
{
{
count_2++;
}
}
{
{
count_2++;
}
}
}
else
{
count_2++;
}
}
count_2++;
}

/*************************************************************************//
///*************************************************************************
{
int count_1=-1;
do
{
count_1++;
{
char *endptr;
{
int flag=0;
{
flag=1;

}
operand[count_2]=x;
else
if(flag)
}
{
break;
break;
break;
break;
break;
}

push(Result);
}
}
char *endptr;
}
/*************************************************************************//
/----------------------------- get_input( ) --------------------------
///*************************************************************************
/void get_input( )
{
do
{
clear_screen( );
gotoxy(6,9);
cout<<"Input :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍ";
gotoxy(37,13);
cout<<"[ n = 2,4,8 ]";
gotoxy(6,12);
cout<<"Enter the max. number of sub-intervals = n = ";
cin>>n;
if(n!=2 && n!=4 && n!=8)
{
gotoxy(12,25);
cout<<"Error : Wrong Input. Press <Esc> to exit or any other key";
gotoxy(12,26);
cout<<" to try again.";
n=int(getche( ));

if(n==27)
exit(0);
}
}
while(n!=2 && n!=4 && n!=8);
gotoxy(6,16);
cout<<"Enter the value of Lower limit = a = ";
cin>>a;
gotoxy(6,18);
cout<<"Enter the value of Upper Limit = b = ";
cin>>b;
gotoxy(25,43);
cout<<"Press any key to continue...";
getch( );
clear_screen( );
gotoxy(6,10);
gotoxy(6,11);
gotoxy(6,37);
gotoxy(6,40);
gotoxy(6,42);
gotoxy(6,44);
gotoxy(6,14);
cin>>Fx;
}

/*************************************************************************//
/---------------------- apply_trapezoidal_rule( ) --------------------
///*************************************************************************
/void apply_trapezoidal_rule( )
{
int count_1=0;
for(int count_2=1;count_2<=n;count_2+=count_2)
{
for(int count_3=0;count_3<max_size;count_3++)
{
xn[count_3]=0;
fx[count_3]=0;
}
h=((b-a)/count_2);
xn[0]=a;
for(int count_4=0;count_4<count_2;count_4++)
xn[(count_4+1)]=(xn[count_4]+h);
for(int count_5=0;count_5<=count_2;count_5++)
fx[count_5]=evaluate_postfix_expression(xn[count_5]);
for(int count_6=1;count_6<count_2;count_6++)
ri[count_1][0]+=fx[count_6];
ri[count_1][0]*=2;
ri[count_1][0]+=fx[0];
ri[count_1][0]+=fx[count_2];
ri[count_1][0]*=(h/2);
count_1++;
}
}
/*************************************************************************//
/---------------------- apply_romberg_method( ) ----------------------
///*************************************************************************
/void apply_romberg_method( )
{
int counter=0;
switch(n)
{
case 2 : counter=1;
break;

case 4 : counter=2;
break;
case 8 : counter=3;
break;
}
for(int count_1=1;count_1<=counter;count_1++)
{
for(int count_2=count_1;count_2<=counter;count_2++)
{
longdouble rjk_1=0;
longdouble rj_1k_1=0;
rjk_1=ri[count_2][(count_1-1)];
rj_1k_1=ri[(count_2-1)][(count_1-1)];
ri[count_2][count_1]=(((powl(4,count_1)*rjk_1)-rj_1k_1)/(powl(4,count_1)-1));
}
}
}
/*************************************************************************//
/---------------------------- show_result( ) -------------------------
///*************************************************************************
{
clear_screen( );
int counter=0;
switch(n)
{
case 2 : counter=1;
break;
case 4 : counter=2;
break;
case 8 : counter=3;
break;
}
gotoxy(6,10);
cout<<"Solution :";
gotoxy(6,11);
cout<<"ÍÍÍÍÍÍÍÍÍÍ";

if(n==1)
{
gotoxy(6,13);
cout<<"ÚÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
}
elseif(n==2)
{
gotoxy(6,13);
cout<<"ÚÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
}
elseif(n==4)
{
gotoxy(6,13);
cout<<"ÚÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
ÄÄÄÄÄÄÄ¿";
}
elseif(n==8)
{
gotoxy(6,13);
cout<<"ÚÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
}
if(n==1)
{
gotoxy(6,14);
cout<<"³ Number of ³ Trapezoidal ³";
}
elseif(n==2)
{
gotoxy(6,14);
cout<<"³ Number of ³ Trapezoidal ³ Romberg Values ³";
}
elseif(n==4)
{
gotoxy(6,14);
}
elseif(n==8)
{
gotoxy(6,14);

}
if(n==1)
{
gotoxy(6,15);
cout<<"³ ³ ³";
}
elseif(n==2)
{
gotoxy(6,15);
cout<<"³ ³ ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
elseif(n==4)
{
gotoxy(6,15);
cout<<"³ ³ ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
elseif(n==8)
{
gotoxy(6,15);
cout<<"³ ³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
if(n==1)
{
gotoxy(6,16);
cout<<"³ Intervals ³ Sums ³";
}
elseif(n==2)
{
gotoxy(6,16);
cout<<"³ Intervals ³ Sums ³ 1ts Order ³";
}
elseif(n==4)
{
gotoxy(6,16);
cout<<"³ Intervals ³ Sums ³ 1ts Order ³ 2nd Order ³";
}
elseif(n==8)
{
gotoxy(6,16);
cout<<"³ Intervals ³ Sums ³ 1ts Order ³ 2nd Order ³ 3rd Order ³";

}
if(n==1)
{
gotoxy(6,17);
cout<<"ÃÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
elseif(n==2)
{
gotoxy(6,17);
cout<<"ÃÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
elseif(n==4)
{
gotoxy(6,17);
cout<<"ÃÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄ
ÄÄÄÄÄÄÄ´";
}
elseif(n==8)
{
gotoxy(6,17);
cout<<"ÃÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
}
if(n==1)
{
gotoxy(6,18);
cout<<"³ ³ ³";
}
elseif(n==2)
{
gotoxy(6,18);
cout<<"³ ³ ³ ³";
}
elseif(n==4)
{
gotoxy(6,18);
cout<<"³ ³ ³ ³ ³";
}
elseif(n==8)
{

gotoxy(6,18);
cout<<"³ ³ ³ ³ ³ ³";
}
int y_cord=19;
int intervals=1;
{
if(n==1)
{
gotoxy(6,y_cord);
cout<<"³ ³ ³";
gotoxy(6,(y_cord+1));
cout<<"³ ³ ³";
}
elseif(n==2)
{
gotoxy(6,y_cord);
cout<<"³ ³ ³ ³";
cout<<"³ ³ ³ ³";
}
elseif(n==4)
{
gotoxy(6,y_cord);
cout<<"³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³";
}
elseif(n==8)
{
gotoxy(6,y_cord);
cout<<"³ ³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³ ³";
}
gotoxy(11,(19+(count_1*2)));
cout<<intervals;
intervals+=intervals;
y_cord+=2;

}
{
{
if(count_2==0)
{
gotoxy(20,(19+(count_3*2)));
cout<<ri[count_3][0];
}
elseif(count_2==1 && count_3>=count_2)
{
gotoxy(34,(19+(count_3*2)));
}
{
gotoxy(48,(19+(count_3*2)));
}
{
gotoxy(62,(19+(count_3*2)));
}
}
}
if(n==1)
{
gotoxy(6,y_cord);
cout<<"ÀÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
elseif(n==2)
{
gotoxy(6,y_cord);
cout<<"ÀÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
elseif(n==4)
{
gotoxy(6,y_cord);

cout<<"ÀÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÙ";
}
elseif(n==8)
{
gotoxy(6,y_cord);
cout<<"ÀÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
gotoxy(6,32);
cout<<" bô";
gotoxy(6,34);
cout<<" aõ";
gotoxy(6,33);
gotoxy(6,35);
gotoxy(8,37);
cout<<"Estimated Integral Value = ";
cout<<ri[counter][counter];
gotoxy(1,2);
}
data yang diberikan menggunakan 1/3 Aturan Simpson di C ++ Programming
# include <stdio.h>
# include <conio.h>
# include <math.h>
int n=0;
int top=-1;
int choice=0;
longdouble h=0;
longdouble a=0;

longdouble b=0;
longdouble estimated_value=0;
/*************************************************************************//
*************************************************************************///
///*************************************************************************
//*************************************************************************/
constchar* pop( );
void get_input( );
void apply_simpsons_rule( );
/*************************************************************************//
*************************************************************************///
------------------------------ main( ) ------------------------------
///*************************************************************************
//*************************************************************************/
int main( )
{
clrscr( );
textmode(C4350);
show_screen( );
get_input( );
apply_simpsons_rule( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//

*************************************************************************///
///*************************************************************************
//*************************************************************************/
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{
cprintf("n******************************************************************
**************");
cprintf("***************************- -
**************************");
cprintf("*--------------------------- ");
textbackground(1);
cprintf(" Numerical Integration ");
textbackground(8);
cprintf(" --------------------------*");
cprintf("*-*************************- -
************************-*");
cprintf("*-
***************************************************************************
*-*");
cprintf("*-* *-*");
gotoxy(1,46);
cprintf("*-
***************************************************************************
*-*");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);
}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
{

gotoxy(5,8+count);
cout<<" ";
}
gotoxy(1,2);
}
/*************************************************************************//
/-------------------------- push(const char*) ------------------------
///*************************************************************************
{
{
getch( );
exit(0);
}
else
{
top++;
}
}
/*************************************************************************//
/------------------------------ pop( ) -------------------------------
///*************************************************************************
/constchar* pop( )
{
if(top==-1)
{
getch( );
exit(0);
}
else
{

top--;
}
return Operand;
}
/*************************************************************************//
///*************************************************************************
{
push("(");
int flag=0;
int count_1=0;
int count_2=0;
flag=1;
do
{
if(flag==0)
{
int count_3=0;
do
{
count_1++;
count_3++;
}

flag=1;
}
elseif(flag==1)
{
count_1++;
flag=0;
flag=0;
}
push("(");
{
{
count_2++;
}
pop( );
}
{
{ }

{
{
count_2++;
}
}
{
{
count_2++;
}
}
}
else
{
count_2++;
}
}
count_2++;
}
/*************************************************************************//
///*************************************************************************
{
int count_1=-1;

do
{
count_1++;
{
char *endptr;
{
int flag=0;
{
flag=1;
}
operand[count_2]=x;

else
if(flag)
}
{
break;
break;
break;
break;
break;
}
push(Result);
}
}
char *endptr;

}
/*************************************************************************//
/----------------------------- get_input( ) --------------------------
///*************************************************************************
/void get_input( )
{
do
{
clear_screen( );
gotoxy(6,9);
cout<<"Number of Sub-Intervals :";
gotoxy(6,10);
gotoxy(20,13);
cout<<"[ min. n = 2 | max. n = 12 ]";
gotoxy(6,12);
cin>>n;
if(n<2 || n>12)
{
gotoxy(12,25);
gotoxy(12,26);
n=int(getche( ));
if(n==27)
exit(0);
}
}
while(n<2 || n>12);
gotoxy(6,16);

cin>>a;
gotoxy(6,18);
cin>>b;
h=((b-a)/n);
gotoxy(6,24);
cout<<"Input Mode :";
gotoxy(6,25);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(8,28);
cout<<"Press : ";
gotoxy(10,30);
cout<<"- 'Y' or <Enter> to enter function";
gotoxy(10,32);
cout<<"- 'N' or <Any other key> to enter values of the function";
gotoxy(8,35);
cout<<"Enter your choice : ";
char Choice=NULL;
Choice=getch( );
if(Choice=='y' || Choice=='Y' || int(Choice)==13)
{
choice=1;
gotoxy(28,35);
cout<<"Y";
}
else
{
gotoxy(28,35);
cout<<"N";
}
gotoxy(25,43);
getch( );

if(choice)
{
clear_screen( );
gotoxy(6,10);
gotoxy(6,11);
gotoxy(6,37);
gotoxy(6,40);
gotoxy(6,42);
gotoxy(6,44);
gotoxy(6,14);
cin>>Fx;
}
clear_screen( );
gotoxy(6,9);
cout<<"Data Points & Values of Function :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(25,12);
cout<<"ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(25,13);
cout<<"³ x ³ f(x) ³";
gotoxy(25,14);
cout<<"ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(25,15);
cout<<"³ ³ ³";

for(int count_1=0;count_1<=n;count_1++)
{
gotoxy(25,(wherey( )+1));
cout<<"³ ³ ³";
cout<<"³ ³ ³";
}
cout<<"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
xn[0]=a;
for(int count_2=0;count_2<n;count_2++)
gotoxy(25,16);
{
gotoxy(27,wherey( ));
cout<<xn[count_3];
if(choice)
{
cout<<fx[count_3];
}
else
{
cin>>fx[count_3];
}
if(choice)
else
}
gotoxy(25,43);
getch( );
}

/*************************************************************************//
/---------------------- apply_simpsons_rule( ) -----------------------
///*************************************************************************
/void apply_simpsons_rule( )
{
longdouble temp=0;
estimated_value=(fx[0]+fx[n]);
estimated_value*=h;
estimated_value/=3;
temp=0;
for(int count_1=2;count_1<=(n-2);count_1+=2)
temp+=fx[count_1];
temp*=(2*h);
temp/=3;
estimated_value+=temp;
temp=0;
for(int count_2=1;count_2<=(n-1);count_2+=2)
temp+=fx[count_2];
temp*=(4*h);
temp/=3;
estimated_value+=temp;
}
/*************************************************************************//
/----------------------------- show_result( ) ------------------------
///*************************************************************************
{
clear_screen( );
gotoxy(6,9);
cout<<"Simpson's 1/3 Rule :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(8,12);
cout<<" bô";

gotoxy(10,13);
cout<<"³f(x)dx ÷ (h/3)(f0+fn) + (2h/3)[f2+f4+...+f(n-2)] +";
gotoxy(50,15);
cout<<"(4h/3)[f1+f3+...+f(n-1)]";
gotoxy(8,14);
cout<<" aõ";
gotoxy(6,17);
cout<<" bô";
gotoxy(6,19);
cout<<" aõ";
gotoxy(6,18);
gotoxy(6,20);
gotoxy(8,23);
cout<<estimated_value;
gotoxy(1,2);
}
data yang diberikan menggunakan aturan trapesium di C ++ Programming
# include <stdio.h>
# include <conio.h>
# include <math.h>
int n=0;
int top=-1;
int choice=0;
longdouble h=0;
longdouble a=0;
longdouble b=0;
longdouble estimated_value=0;

/*************************************************************************//
*************************************************************************///
///*************************************************************************
//*************************************************************************/
constchar* pop( );
void get_input( );
void apply_trapezoidal_rule( );
/*************************************************************************//
*************************************************************************///
------------------------------ main( ) ------------------------------
///*************************************************************************
//*************************************************************************/
int main( )
{
clrscr( );
textmode(C4350);
show_screen( );
get_input( );
apply_trapezoidal_rule( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//
*************************************************************************///

///*************************************************************************
//*************************************************************************/
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{
cprintf("n******************************************************************
**************");
cprintf("***************************- -
**************************");
cprintf("*--------------------------- ");
textbackground(1);
cprintf(" Numerical Integration ");
textbackground(8);
cprintf(" --------------------------*");
cprintf("*-*************************- -
************************-*");
cprintf("*-
***************************************************************************
*-*");
cprintf("*-* *-*");
gotoxy(1,46);
cprintf("*-
***************************************************************************
*-*");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);
}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
{
gotoxy(5,8+count);
cout<<" ";

}
gotoxy(1,2);
}
/*************************************************************************//
/-------------------------- push(const char*) ------------------------
///*************************************************************************
{
{
getch( );
exit(0);
}
else
{
top++;
}
}
/*************************************************************************//
/------------------------------ pop( ) -------------------------------
///*************************************************************************
/constchar* pop( )
{
if(top==-1)
{
getch( );
exit(0);
}
else
{
top--;
}

return Operand;
}
/*************************************************************************//
///*************************************************************************
{
push("(");
int flag=0;
int count_1=0;
int count_2=0;
flag=1;
do
{
if(flag==0)
{
int count_3=0;
do
{
count_1++;
count_3++;
}

flag=1;
}
elseif(flag==1)
{
count_1++;
flag=0;
flag=0;
}
push("(");
{
{
count_2++;
}
pop( );
}
{
{ }

{
{
count_2++;
}
}
{
{
count_2++;
}
}
}
else
{
count_2++;
}
}
count_2++;
}
/*************************************************************************//
///*************************************************************************
{
int count_1=-1;

do
{
count_1++;
{
char *endptr;
{
int flag=0;
{
flag=1;
}
operand[count_2]=x;

else
if(flag)
}
{
break;
break;
break;
break;
break;
}
push(Result);
}
}
char *endptr;

}
/*************************************************************************//
/----------------------------- get_input( ) --------------------------
///*************************************************************************
/void get_input( )
{
do
{
clear_screen( );
gotoxy(6,9);
cout<<"Number of Sub-Intervals :";
gotoxy(6,10);
gotoxy(20,13);
cout<<"[ min. n = 3 | max. n = 12 ]";
gotoxy(6,12);
cin>>n;
if(n<3 || n>12)
{
gotoxy(12,25);
gotoxy(12,26);
n=int(getche( ));
if(n==27)
exit(0);
}
}
while(n<3 || n>12);
gotoxy(6,16);
cin>>a;

gotoxy(6,18);
cin>>b;
h=((b-a)/n);
gotoxy(6,24);
gotoxy(6,25);
gotoxy(8,28);
cout<<"Press : ";
gotoxy(10,30);
gotoxy(10,32);
gotoxy(8,35);
char Choice=NULL;
Choice=getch( );
{
choice=1;
gotoxy(28,35);
cout<<"Y";
}
else
{
gotoxy(28,35);
cout<<"N";
}
gotoxy(25,43);
getch( );
if(choice)
{

clear_screen( );
gotoxy(6,10);
gotoxy(6,11);
gotoxy(6,37);
gotoxy(6,40);
gotoxy(6,42);
gotoxy(6,44);
gotoxy(6,14);
cin>>Fx;
}
clear_screen( );
gotoxy(6,9);
gotoxy(6,10);
gotoxy(25,12);
gotoxy(25,13);
cout<<"³ x ³ f(x) ³";
gotoxy(25,14);
gotoxy(25,15);
cout<<"³ ³ ³";
{

cout<<"³ ³ ³";
cout<<"³ ³ ³";
}
xn[0]=a;
gotoxy(25,16);
{
cout<<xn[count_3];
if(choice)
{
cout<<fx[count_3];
}
else
{
cin>>fx[count_3];
}
if(choice)
else
}
gotoxy(25,43);
getch( );
}

/*************************************************************************//
/---------------------- apply_trapezoidal_rule( ) --------------------
///*************************************************************************
/void apply_trapezoidal_rule( )
{
for(int count=1;count<n;count++)
estimated_value+=fx[count];
estimated_value*=2;
estimated_value+=fx[0];
estimated_value+=fx[n];
estimated_value*=(h/2);
}
/*************************************************************************//
/--------------------------- show_result( ) --------------------------
///*************************************************************************
{
clear_screen( );
gotoxy(6,9);
cout<<"Trapeziodal Rule :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(8,12);
cout<<" bô";
gotoxy(10,13);
cout<<"³f(x)dx ÷ (h/2)[f0+{2*(f1+f2+...+fn-1)}+fn]";
gotoxy(8,14);
cout<<" aõ";
gotoxy(6,17);
cout<<" bô";
gotoxy(6,19);
cout<<" aõ";
gotoxy(6,18);
gotoxy(6,20);

gotoxy(8,23);
cout<<estimated_value;
gotoxy(1,2);
}
5. Program untuk memperkirakan nilai derivatif pertama dari fungsi pada titik-titik
tertentu dari data yang diberikan menggunakan Tengah Perbedaan Formula di C ++
Programming
# include <stdio.h>
# include <conio.h>
# include <math.h>
int n=0;
int top=-1;
int choice=0;
longdouble h=0;
longdouble x0=0;
char Dfx[100]={NULL};
char Postfix_expression[2][30][30]={NULL};
void convert_ie_to_pe(constchar *,constint);
constchar* pop( );
constlongdouble evaluate_postfix_expression(constlongdouble,constint);
void get_input( );
void estimate_dfx( );
constint get_index(constlongdouble);
int main( )
{
clrscr( );

textmode(C4350);
show_screen( );
get_input( );
estimate_dfx( );
return 0;
}
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{
cprintf("n******************************************************************
**************");
cprintf("*************************- -
************************");
cprintf("*------------------------- ");
textbackground(1);
cprintf(" Numerical Differentiation ");
textbackground(8);
cprintf(" ------------------------*");
cprintf("*-***********************- -**********************-
*");
cprintf("*-
***************************************************************************
*-*");
cprintf("*-* *-*");
gotoxy(1,46);
cprintf("*-
***************************************************************************
*-*");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);
}

/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
{
gotoxy(5,8+count);
cout<<" ";
}
gotoxy(1,2);
}
/*************************************************************************//
/-------------------------- push(const char*) ------------------------
///*************************************************************************
{
{
getch( );
exit(0);
}
else
{
top++;
}
}
/*************************************************************************//
/------------------------------ pop( ) -------------------------------
///*************************************************************************
/constchar* pop( )
{
if(top==-1)
{

getch( );
exit(0);
}
else
{
top--;
}
return Operand;
}
/*************************************************************************//
/---------------- convert_ie_to_pe(const char*,const int) ------------
///*************************************************************************
/void convert_ie_to_pe(constchar* Expression,constint index)
{
push("(");
int flag=0;
int count_1=0;
int count_2=0;
flag=1;
do
{
if(flag==0)
{
int count_3=0;
do
{
count_1++;
count_3++;
}

flag=1;
}
elseif(flag==1)
{
count_1++;
flag=0;
flag=0;
}
push("(");
{
{
strcpy(Postfix_expression[index][count_2],pop( ));
count_2++;
}
pop( );
}

{
{ }
{
{
count_2++;
}
}
{
{
count_2++;
}
}
}
else
{
strcat(Postfix_expression[index][count_2],Symbol_scanned);
count_2++;
}
}
strcat(Postfix_expression[index][count_2],"=");
count_2++;
}
/*************************************************************************//

/----- evaluate_postfix_expression(const long double,const int) ------
///*************************************************************************
/constlongdouble evaluate_postfix_expression(
constlongdouble x,constint index)
{
int count_1=-1;
do
{
count_1++;
strcpy(Symbol_scanned,Postfix_expression[index][count_1]);
{
char *endptr;
{
int flag=0;
{
flag=1;
}

operand[count_2]=x;
else
if(flag)
}
{
break;
break;
break;
break;
break;
}
push(Result);

}
}
char *endptr;
}
/*************************************************************************//
/----------------------------- get_input( ) --------------------------
///*************************************************************************
/void get_input( )
{
do
{
clear_screen( );
gotoxy(6,9);
cout<<"Number of Distinct Data Points :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(27,13);
cout<<"[ min. n = 3 | max. n = 12 ]";
gotoxy(6,12);
cout<<"Enter the max. number of distinct data points = n = ";
cin>>n;
if(n<3 || n>12)
{
gotoxy(12,25);
gotoxy(12,26);
n=int(getche( ));

if(n==27)
exit(0);
}
}
while(n<3 || n>12);
gotoxy(6,16);
cout<<"Enter the value of x0 = ";
cin>>x0;
gotoxy(6,18);
cout<<"Enter the value of h = ";
cin>>h;
gotoxy(6,24);
gotoxy(6,25);
gotoxy(8,28);
cout<<"Press : ";
gotoxy(10,30);
gotoxy(10,32);
gotoxy(8,35);
char Choice=NULL;
Choice=getch( );
{
choice=1;
gotoxy(28,35);
cout<<"Y";
}
else
{
gotoxy(28,35);
cout<<"N";

}
gotoxy(25,43);
getch( );
if(choice)
{
clear_screen( );
gotoxy(6,11);
gotoxy(6,12);
gotoxy(6,37);
gotoxy(6,40);
gotoxy(6,42);
gotoxy(6,44);
gotoxy(6,14);
cin>>Fx;
gotoxy(6,17);
cout<<"Enter the Differential Function : f'(x) = ";
cin>>Dfx;
convert_ie_to_pe(Fx,0);
convert_ie_to_pe(Dfx,1);
}
clear_screen( );
gotoxy(6,9);
gotoxy(6,10);

gotoxy(25,12);
gotoxy(25,13);
cout<<"³ x ³ f(x) ³";
gotoxy(25,14);
gotoxy(25,15);
cout<<"³ ³ ³";
{
cout<<"³ ³ ³";
cout<<"³ ³ ³";
}
xn[0]=x0;
for(int count_2=0;count_2<(n-1);count_2++)
gotoxy(25,16);
{
cout<<xn[count_3];
if(choice)
{
fx[count_3]=evaluate_postfix_expression(xn[count_3],0);
cout<<fx[count_3];
}
else
{
cin>>fx[count_3];
}

if(choice)
else
}
gotoxy(25,43);
getch( );
}
/*************************************************************************//
/------------------- get_index(const long double) --------------------
///*************************************************************************
/constint get_index(constlongdouble x)
{
for(int count=0;count<n;count++)
{
if(xn[count]==x)
break;
}
return count;
}
/*************************************************************************//
/---------------------------- estimate_dfx( ) ------------------------
///*************************************************************************
/void estimate_dfx( )
{
clear_screen( );
gotoxy(6,9);
cout<<"Centeral Difference Formula of Order 2 :";
gotoxy(6,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
gotoxy(8,13);
cout<<"f'(x) ÷ [f(x+h)-f(x-h)]/2h";
gotoxy(6,17);
cout<<"Estimation of f'(x) :";
gotoxy(6,18);

char Choice=NULL;
longdouble x=0;
longdouble dfx=0;
longdouble actual_dfx=0;
int error_flag=0;
do
{
Choice=NULL;
x=0;
dfx=0;
actual_dfx=0;
error_flag=0;
gotoxy(10,20);
cout<<"Enter the value of x = ";
cin>>x;
if(x<=xn[0] || x>=xn[(n-1)])
{
error_flag=1;
gotoxy(10,23);
cout<<"Error: Please enter x greater than x(0) and less than x(n).";
}
else
{
int index=0;
index=get_index(x);
longdouble fxph=fx[(index+1)];
longdouble fxmh=fx[(index-1)];
dfx=((fxph-fxmh)/(2*h));
gotoxy(10,23);
cout<<"The estimated value of f'("<<x<<") ÷ "<<dfx;
}
if(choice && !error_flag)
{
actual_dfx=evaluate_postfix_expression(x,1);

gotoxy(10,25);
cout<<"The Actual value of f'("<<x<<") = "<<actual_dfx;
gotoxy(10,28);
cout<<"Absolute Error = E(abs) = "<<fabs((actual_dfx-dfx));
}
gotoxy(15,42);
cout<<"Press <Esc> to exit or any other key to continue...";
Choice=getch( );
if(int(Choice)!=27)
{
gotoxy(10,20);
cout<<" ";
gotoxy(10,23);
cout<<" ";
gotoxy(10,25);
cout<<" ";
gotoxy(10,28);
cout<<" ";
gotoxy(15,42);
cout<<" ";
}
elseif(int(Choice)==27)
exit(0);
}
while(1);
}
6. Program untuk membaca Sistem Linear dari Persamaan, kemudian mengevaluasi
dengan menggunakan Gauss-Seidel Metode Iteratif dan menampilkan hasil di C ++
Programming
# include <stdio.h>
# include <conio.h>
# include <math.h>
int n=0;
int iterations=0;

char Diagonally_dominant=NULL;
longdouble input[max_size][max_size]={0};
longdouble previous_output[max_size]={0};
longdouble output[max_size]={0};
void get_size_of_linear_equations( );
void show_input(constint,constint);
void get_input_linear_equation( );
void sort_system_of_linear_equations( );
void apply_guass_seidel_iterative_method( );
int main( )
{
clrscr( );
textmode(C4350);
show_screen( );
get_size_of_linear_equations( );
get_input_linear_equation( );
if(Diagonally_dominant=='Y' || Diagonally_dominant=='y')
sort_system_of_linear_equations( );
apply_guass_seidel_iterative_method( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{
cprintf("n******************************************************************
**************");
cprintf("**********************- -**********************");
cprintf("*---------------------- ");
textbackground(1);
cprintf(" Guass-Seidel's Itrative Method ");
textbackground(8);

cprintf(" ----------------------*");
cprintf("**********************- -**********************");
cprintf("********************************************************************
************");
cprintf("* *");
gotoxy(1,46);
cprintf("********************************************************************
************");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);
}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
textbackground(8);
{
gotoxy(3,8+count);
cout<<" ";
}
gotoxy(1,2);
}
/*************************************************************************//
/------------------ get_size_of_linear_equations( ) ------------------
///*************************************************************************
/void get_size_of_linear_equations( )
{
do
{
clear_screen( );
gotoxy(38,11);

cout<<"[ Maximum size = 4 ]";
gotoxy(4,9);
cout<<"Enter the size of the System of Linear Equations = n = ";
cin>>n;
if(n<=0 || n>max_size)
{
gotoxy(12,25);
gotoxy(12,26);
n=int(getche( ));
if(n==27)
exit(0);
}
}
while(n<=0 || n>max_size);
gotoxy(4,15);
cout<<"Enter the number of iterations that you want to perform = ";
cin>>iterations;
gotoxy(4,18);
cout<<"Do you want to make the System Diagonally Dominant : (Y/N) ? : ";
cin>>Diagonally_dominant;
gotoxy(1,2);
}
/*************************************************************************//
/------------------ show_input(const int,const int) ------------------
///*************************************************************************
/void show_input(constint x,constint y)
{
int counter=0;
int number_of_inputs=((x*n)+y+x);
{
gotoxy(4,(17+(count_1*2)));
cout<<" ";

{
if(counter==(number_of_inputs+1))
textbackground(12);
else
textbackground(8);
if(count_2==n)
gotoxy((wherex( )+5),(17+(count_1*2)));
gotoxy(wherex( ),(17+(count_1*2)));
cprintf(" ");
if(count_2==n)
gotoxy((wherex( )-5),(17+(count_1*2)));
if(counter<=number_of_inputs && counter!=-1)
{
if(count_2==n)
{
cout<<" = ";
cout<<input[count_1][count_2];
}
elseif(count_2==0)
cout<<input[count_1][count_2]<<" x"<<(count_2+1);
else
cout<<fabs(input[count_1][count_2])<<" x"<<(count_2+1);
}
elseif(count_2==n)
cout<<" = b"<<(count_1+1);
else
cout<<"a"<<(count_1+1)<<(count_2+1)<<" x"<<(count_2+1);
if(count_2<(n-1) && input[count_1][(count_2+1)]>=0)
cout<<" + ";
elseif(count_2<(n-1))
cout<<" - ";
counter++;
}

}
}
/*************************************************************************//
/-------------------- get_input_linear_equation( ) -------------------
///*************************************************************************
/void get_input_linear_equation( )
{
clear_screen( );
gotoxy(4,9);
cout<<"Size of the System of Linear Equations = n = "<<n;
gotoxy(4,13);
cout<<"System of Linear Equations :";
gotoxy(4,14);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
show_input(0,-1);
{
{
gotoxy(4,35);
cout<<" ";
gotoxy(4,35);
if(count_2<n)
cout<<"Enter the value of a"<<(count_1+1)<<(count_2+1)<<" = ";
else
cout<<"Enter the value of b"<<(count_1+1)<<" = ";
cin>>input[count_1][count_2];
show_input(count_1,count_2);
}
}
}
/*************************************************************************//
/----------------- sort_system_of_linear_equations( ) ----------------
///*************************************************************************
/void sort_system_of_linear_equations( )
{

{
for(int count_2=count_1;count_2<(n-1);count_2++)
{
{
longdouble temp[max_size]={0};
if(fabs(input[count_3][count_1])<
fabs(input[(count_3+1)][count_1]))
{
temp[count_4]=input[count_3][count_4];
input[count_3][count_5]=
input[(count_3+1)][count_5];
input[(count_3+1)][count_6]=temp[count_6];
}
}
}
}
}
/*************************************************************************//
/--------------- apply_guass_seidel_iterative_method( ) --------------
///*************************************************************************
/void apply_guass_seidel_iterative_method( )
{
clear_screen( );
gotoxy(4,10);
cout<<"Solution :";
gotoxy(4,11);
if(n==1)
{
gotoxy(4,13);
cout<<"ÚÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³";
gotoxy(4,15);
cout<<"ÃÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";

gotoxy(4,16);
cout<<"³ ³ ³";
}
elseif(n==2)
{
gotoxy(4,13);
cout<<"ÚÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³";
gotoxy(4,15);
cout<<"ÃÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³";
}
elseif(n==3)
{
gotoxy(4,13);
cout<<"ÚÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³ X3 ³";
gotoxy(4,15);
cout<<"ÃÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³ ³";
}
elseif(n==4)
{
gotoxy(4,13);
ÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³ X3 ³ X4 ³";
gotoxy(4,15);

ÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³ ³ ³";
}
{
{
if(count_2!=count_1)
temp[count_2]=(input[count_1][count_2]/input[count_1][count_1]);
}
input[count_1][count_3]=temp[count_3];
}
{
input[count_4][count_5]*=-1;
}
int x_cord=4;
int y_cord=17;
for(int count_6=0;count_6<=iterations;count_6++)
{
if(n==1)
{
gotoxy(x_cord,y_cord);
cout<<"³ ³ ³";
gotoxy(x_cord,(y_cord+1));
cout<<"³ ³ ³";
}
elseif(n==2)
{
cout<<"³ ³ ³ ³";
cout<<"³ ³ ³ ³";
}

elseif(n==3)
{
cout<<"³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³";
}
elseif(n==4)
{
cout<<"³ ³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³ ³";
}
gotoxy((x_cord+3),y_cord);
cout<<count_6;
cout<<output[0];
if(n>=2)
{
cout<<output[1];
}
if(n>=3)
{
cout<<output[2];
}
if(n>=4)
{
cout<<output[3];
}
{
output[count_7]=0;
{

output[count_7]+=(input[count_7][count_8]*previous_output[count_8]);
}
output[count_7]+=input[count_7][count_8];
previous_output[count_7]=output[count_7];
}
y_cord+=2;
if((count_6%12)==0 && count_6<iterations && count_6>0)
{
y_cord=17;
gotoxy(30,44);
getch( );
{
gotoxy(3,(16+count_9));
cout<<" ";
}
}
}
if(n==1)
{
cout<<"ÀÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
elseif(n==2)
{
cout<<"ÀÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
elseif(n==3)
{
cout<<"ÀÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÄÄÙ";
}
elseif(n==4)
{

cout<<"ÀÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄ
ÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ";
}
gotoxy(30,44);
getch( );
}
/*************************************************************************//
/----------------------------- show_result( ) ------------------------
///*************************************************************************
{
clear_screen( );
gotoxy(4,9);
cout<<"Gauss-Seidel System of Linear Equations :";
gotoxy(4,10);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
{
cout<<"x"<<(count_1+1);
gotoxy((wherex( )-1),(wherey( )-1));
cout<<"(k+1)";
gotoxy((wherex( )-3),(wherey( )+1));
cout<<" = ";
{
if(count_2!=count_1 && count_2<n)
{
if(count_2!=0)
else
gotoxy((wherex( )-1),(wherey( )-1));
if(count_2<count_1)

cout<<"(k+1)";
else
cout<<"(k)";
gotoxy((wherex( )-1),(wherey( )+1));
if(input[count_1][(count_2+1)]>=0)
cout<<" + ";
else
cout<<" - ";
}
elseif(count_2!=count_1)
cout<<fabs(input[count_1][count_2]);
}
}
{
gotoxy(4,26);
cout<<"Note: The given System of Linear Equations is solved by making it";
gotoxy(10,28);
cout<<"Diagonally Dominant.";
}
gotoxy(4,31);
cout<<"Result of Given System of Linear Equations :";
gotoxy(4,32);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
{
gotoxy(8,(34+count_3+count_3));
cout<<"x"<<(count_3+1)<<" = "<<output[count_3];
}
gotoxy(4,(36+count_3+count_3));
cout<<"* Number of Iterations for the above result = "<<iterations<<".";
gotoxy(1,2);
}
7. Program untuk membaca Sistem Linear dari Persamaan, kemudian mengevaluasi
dengan menggunakan Metode Itrative Jacobi dan menampilkan hasil di C ++
Programming

# include <stdio.h>
# include <conio.h>
# include <math.h>
int n=0;
int iterations=0;
char Diagonally_dominant=NULL;
longdouble input[max_size][max_size]={0};
longdouble previous_output[max_size]={0};
longdouble output[max_size]={0};
void get_size_of_linear_equations( );
void show_input(constint,constint);
void get_input_linear_equation( );
void sort_system_of_linear_equations( );
void apply_jacobi_iterative_method( );
int main( )
{
clrscr( );
textmode(C4350);
show_screen( );
get_size_of_linear_equations( );
get_input_linear_equation( );
sort_system_of_linear_equations( );
apply_jacobi_iterative_method( );
show_result( );
getch( );
return 0;
}
/*************************************************************************//
/-------------------------- show_screen( ) ---------------------------
///*************************************************************************
{

cprintf("n******************************************************************
**************");
cprintf("*************************- -
*************************");
cprintf("*------------------------- ");
textbackground(1);
cprintf(" Jacobi's Itrative Method ");
textbackground(8);
cprintf(" -------------------------*");
cprintf("************************- -
*************************");
cprintf("********************************************************************
************");
cprintf("* *");
gotoxy(1,46);
cprintf("********************************************************************
************");
cprintf("*------------------------------------------------------------------------------*");
cprintf("********************************************************************
************");
gotoxy(1,2);
}
/*************************************************************************//
/------------------------- clear_screen( ) ---------------------------
///*************************************************************************
{
textbackground(8);
{
gotoxy(3,8+count);
cout<<" ";
}
gotoxy(1,2);
}

/*************************************************************************//
/------------------ get_size_of_linear_equations( ) ------------------
///*************************************************************************
/void get_size_of_linear_equations( )
{
do
{
clear_screen( );
gotoxy(38,11);
cout<<"[ Maximum size = 4 ]";
gotoxy(4,9);
cout<<"Enter the size of the System of Linear Equations = n = ";
cin>>n;
if(n<=0 || n>max_size)
{
gotoxy(12,25);
gotoxy(12,26);
n=int(getche( ));
if(n==27)
exit(0);
}
}
while(n<=0 || n>max_size);
gotoxy(4,15);
cout<<"Enter the number of iterations that you want to perform = ";
cin>>iterations;
gotoxy(4,18);
cout<<"Do you want to make the System Diagonally Dominant : (Y/N) ? : ";
cin>>Diagonally_dominant;
gotoxy(1,2);
}
/*************************************************************************//
/----------------- show_input(const int,const int) -------------------

///*************************************************************************
/void show_input(constint x,constint y)
{
int counter=0;
int number_of_inputs=((x*n)+y+x);
{
cout<<" ";
{
if(counter==(number_of_inputs+1))
textbackground(12);
else
textbackground(8);
if(count_2==n)
gotoxy((wherex( )+5),(17+(count_1*2)));
cprintf(" ");
if(count_2==n)
if(counter<=number_of_inputs && counter!=-1)
{
if(count_2==n)
{
cout<<" = ";
cout<<input[count_1][count_2];
}
elseif(count_2==0)
else
}
elseif(count_2==n)
cout<<" = b"<<(count_1+1);

else
cout<<"a"<<(count_1+1)<<(count_2+1)<<" x"<<(count_2+1);
if(count_2<(n-1) && input[count_1][(count_2+1)]>=0)
cout<<" + ";
elseif(count_2<(n-1))
cout<<" - ";
counter++;
}
}
}
/*************************************************************************//
/-------------------- get_input_linear_equation( ) -------------------
///*************************************************************************
/void get_input_linear_equation( )
{
clear_screen( );
gotoxy(4,9);
cout<<"Size of the System of Linear Equations = n = "<<n;
gotoxy(4,13);
cout<<"System of Linear Equations :";
gotoxy(4,14);
cout<<"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ";
show_input(0,-1);
{
{
gotoxy(4,35);
cout<<" ";
gotoxy(4,35);
if(count_2<n)
cout<<"Enter the value of a"<<(count_1+1)<<(count_2+1)<<" = ";
else
cout<<"Enter the value of b"<<(count_1+1)<<" = ";
cin>>input[count_1][count_2];

show_input(count_1,count_2);
}
}
}
/*************************************************************************//
/----------------- sort_system_of_linear_equations( ) ----------------
///*************************************************************************
/void sort_system_of_linear_equations( )
{
{
{
{
if(fabs(input[count_3][count_1])<
fabs(input[(count_3+1)][count_1]))
{
temp[count_4]=input[count_3][count_4];
input[count_3][count_5]=
input[(count_3+1)][count_5];
input[(count_3+1)][count_6]=temp[count_6];
}
}
}
}
}
/*************************************************************************//
/------------------ apply_jacobi_iterative_method( ) -----------------
///*************************************************************************
/void apply_jacobi_iterative_method( )
{
clear_screen( );
gotoxy(4,10);
cout<<"Solution :";
gotoxy(4,11);

if(n==1)
{
gotoxy(4,13);
cout<<"ÚÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³";
gotoxy(4,15);
cout<<"ÃÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³";
}
elseif(n==2)
{
gotoxy(4,13);
cout<<"ÚÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³";
gotoxy(4,15);
cout<<"ÃÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³";
}
elseif(n==3)
{
gotoxy(4,13);
ÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³ X3 ³";
gotoxy(4,15);
ÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³ ³";
}

elseif(n==4)
{
gotoxy(4,13);
ÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿";
gotoxy(4,14);
cout<<"³ n ³ X1 ³ X2 ³ X3 ³ X4 ³";
gotoxy(4,15);
ÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´";
gotoxy(4,16);
cout<<"³ ³ ³ ³ ³ ³";
}
{
{
temp[count_2]=(input[count_1][count_2]/input[count_1][count_1]);
}
input[count_1][count_3]=temp[count_3];
}
{
input[count_4][count_5]*=-1;
}
int x_cord=4;
int y_cord=17;
for(int count_6=0;count_6<=iterations;count_6++)
{
if(n==1)
{
cout<<"³ ³ ³";

cout<<"³ ³ ³";
}
elseif(n==2)
{
cout<<"³ ³ ³ ³";
cout<<"³ ³ ³ ³";
}
elseif(n==3)
{
cout<<"³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³";
}
elseif(n==4)
{
cout<<"³ ³ ³ ³ ³ ³";
cout<<"³ ³ ³ ³ ³ ³";
}
cout<<count_6;
cout<<output[0];
if(n>=2)
{
cout<<output[1];
}
if(n>=3)
{
cout<<output[2];
}
if(n>=4)
{

Aplikasi menghitung matematika dengan c++

Aplikasi menghitung matematika dengan c++

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (12)

Similar to Aplikasi menghitung matematika dengan c++

Similar to Aplikasi menghitung matematika dengan c++ (20)

More from radar radius

More from radar radius (20)

Recently uploaded

Recently uploaded (20)

Aplikasi menghitung matematika dengan c++