# include <stdlib.

h>
# include <stdio.h>
# include <math.h>
# include <omp.h>
int main ( void );
void jacobi ( int n, double a[], double b[], double x[], double x_old[] );
void r8vec_uniform_01 ( int n, int *seed, double r[] );
/******************************************************************************/
int main ( void )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for JACOBI.
*/
{
double *a;
double *b;
int i;
int j;
int n = 500;
double row_sum;
int seed;
double *x;
double *x_old;
a = ( double * ) malloc ( n * n * sizeof ( double ) );
b = ( double * ) malloc ( n * sizeof ( double ) );
x = ( double * ) malloc ( n * sizeof ( double ) );
x_old = ( double * ) malloc ( n * sizeof ( double ) );
printf ( "\n" );
printf ( "JACOBI\n" );
printf ( " C version\n" );
printf ( " Number of threads = %d\n", omp_get_max_threads ( ) );
printf ( " Problem size N = %d\n", n );
seed = 123456789;
r8vec_uniform_01 ( n * n, &seed, a );
for ( i = 0; i < n; i++ )
{
row_sum = 0.0;
for ( j = 0; j < n; j++ )
{
row_sum = row_sum + fabs ( a[i+j*n] );
}
a[i+i*n] = 1.0 + 2.0 * row_sum;
}

for ( i = 0; i < n; i++ )

{
x[i] = ( double ) ( i + 1 );
}
for ( i = 0; i < n; i++ )
{
b[i] = 0.0;
for ( j = 0; j < n; j++ )
{
b[i] = b[i] + a[i+j*n] * x[j];
}
}
r8vec_uniform_01 ( n, &seed, x );
jacobi ( n, a, b, x, x_old );
free ( a );
free ( b );
free ( x );
free ( x_old );
return 0;
}
/******************************************************************************/
void jacobi ( int n, double a[], double b[], double x[], double x_old[] )
/******************************************************************************/
/*
Purpose:
JACOBI carries out the Jacobi iteration.
*/
{
double axi;
double diff;
double diff_tol;
int i;
int it;
int it_max = 100;
int j;
double r8_epsilon = 1.0E-14;
double wtime;
double wtime1;
double wtime2;
diff_tol = 0.0;
for ( i = 0; i < n; i++ )
{
diff_tol = diff_tol + fabs ( b[i] );
}
diff_tol = ( diff_tol + 1.0 ) * r8_epsilon;

wtime1 = omp_get_wtime ( );
for ( it = 1; it <= it_max; it++ )
{
for ( i = 0; i < n; i++ )
{
x_old[i] = x[i];
}
for ( i = 0; i < n; i++ )
{
axi = 0.0;
for ( j = 0; j < n; j++ )
{
axi = axi + a[i+j*n] * x_old[j];
}
x[i] = x_old[i] + ( b[i] - axi ) / a[i+i*n];
}
diff = 0.0;
for ( i = 0; i < n; i++ )
{
diff = diff + fabs ( x[i] - x_old[i] );
}
printf ( " %8d %14e\n", it, diff );
if ( diff <= diff_tol )
{
break;
}
}
wtime2 = omp_get_wtime ( );
wtime = wtime2 - wtime1;
printf ( "\n" );
printf ( "DIFF = %e\n", diff );
printf ( "DIFF_TOL = %e\n", diff_tol );
printf ( "Time = %e\n", wtime );
for ( i = 0; i < 10; i++ )
{
printf ( " %8d %14f\n", i, x[i] );
}
return;
}
/******************************************************************************/
void r8vec_uniform_01 ( int n, int *seed, double r[] )
/******************************************************************************/
/*

Purpose:
R8VEC_UNIFORM_01 returns a unit pseudorandom vector.
Parameters:
Input, int N, the number of entries in the vector.
Input/output, int *SEED, a seed for the random number generator.
Output, double R[N], the vector of pseudorandom values.
*/
{
int i;
int i4_huge = 2147483647;
int k;
if ( *seed == 0 )
{
printf ( "\n" );
printf ( "R8VEC_UNIFORM_01 - Fatal error!\n" );
printf ( " Input value of SEED = 0.\n" );
exit ( 1 );
}
for ( i = 0; i < n; i++ )
{
k = *seed / 127773;
*seed = 16807 * ( *seed - k * 127773 ) - k * 2836;
if ( *seed < 0 )
{
*seed = *seed + i4_huge;
}
r[i] = ( double ) ( *seed ) * 4.656612875E-10;
}
return;
}

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define e 0.01
void main()
{
int i,j,k,n;
float a[10][10],x[10];
float sum,temp,error,big;
printf("Enter the number of equations: ");
scanf("%d",&n) ;
printf("Enter the co-efficients of the equations: \n");

for(i=1;i<=n;i++)
{
for(j=1;j<=n+1;j++)
{
printf("a[%d][%d]= ",i,j);
scanf("%f",&a[i][j]);
}
}
for(i=1;i<=n;i++)
{
x[i]=0;
}
do
{
big=0;
for(i=1;i<=n;i++)
{
sum=0;
for(j=1;j<=n;j++)
{
if(j!=i)
{
sum=sum+a[i][j]*x[j];
}
}
temp=(a[i][n+1]-sum)/a[i][i];

error=fabs(x[i]-temp);
if(error>big)
{
big=error;
}
x[i]=temp;
printf("\nx[%d] =%f",i,x[i]);
}printf("\n");
}
while(big>=e);
printf("\n\nconverges to solution");
for(i=1;i<=n;i++)
{
printf("\nx[%d]=%f",i,x[i]);
}
getch();
}

ch olesky
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
double *cholesky(double *A, int n) {
double *L = (double*)calloc(n * n, sizeof(double));
if (L == NULL)
exit(EXIT_FAILURE);
for (int i = 0; i < n; i++)
for (int j = 0; j < (i+1); j++) {
double s = 0;
for (int k = 0; k < j; k++)
s += L[i * n + k] * L[j * n + k];
L[i * n + j] = (i == j) ?
sqrt(A[i * n + i] - s) :
(1.0 / L[j * n + j] * (A[i * n + j] - s));
}
return L;
}
void show_matrix(double *A, int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
printf("%2.5f ", A[i * n + j]);
printf("\n");
}
}
int main() {
int n = 3;
double m1[] = {25, 15, -5,
15, 18, 0,

-5, 0, 11};
double *c1 = cholesky(m1, n);
show_matrix(c1, n);
printf("\n");
free(c1);
n = 4;
double m2[] = {18, 22, 54, 42,
22, 70, 86, 62,
54, 86, 174, 134,
42, 62, 134, 106};
double *c2 = cholesky(m2, n);
show_matrix(c2, n);
free(c2);
return 0;
}