Лабораторные работы 1 2 3 5 / addiction

#include <conio.h>
#include <iostream.h>
#include "addiction.h"
#include "displ.h"


float power(float m, unsigned int e)
{
	float result = 1;
	for(int i = 0; i < e; i++)
		result *= m;
	return result;
}
//////////////////////////////////////
long factorial(unsigned int n)
{
	if (n > 10)
		return -1;
	
	int n1 = n;
	long result = 1;
	if (n1 == 0)
		return 1;
	while (n1 > 0)
	{
        result *= n1;
		n1--;
	}
	return result;
}
/////////////////////////////////////////
long comb(unsigned int n, unsigned int k)
{
	if (n > 10 || k > n)
		return -1;

	long z1 = factorial(n), z2 = factorial(k),  z3 = factorial(n-k);
    return z1/(z2*z3);
}
/////////////////////////////////////////
void flout(const float (*P)[MAXSIZE], unsigned int m, unsigned int n)
{
	if (m <= 0 || m > MAXSIZE) 
	{
		cout << '!';
		return;
	}
	int i, j;

	if (n == 0)
		n = m;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
			cout << P[i][j] << ' ';
		cout << endl;
	}
}
/////////////////////////////////////////
void mmult(float (*P)[MAXSIZE], float *x, unsigned int n)
{
	if( P == NULL || x == NULL || n <= 0 || n > MAXSIZE)
		return;
	float *y = (float*)malloc(n * sizeof(float));
	unsigned int i, j;
	for (i = 0; i < n; i++)
		*(y + i) = 0;
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
			*(y + i) = *(y + i) + P[i][j]*x[j];
	for (i = 0; i < n; i++)
		*(x + i) = *(y + i);
	free(y);
}
//////////////////////////////////////////
///Проверка матрицы на трехдиагональность///
int is_3diag(const float(*P)[MAXSIZE], unsigned int n)
{
	if (P == NULL || n <= 0 || n > MAXSIZE)
		return 0;
	unsigned int i, j;    
	for (i = 0; i < n ; i++)
		 for (j = 0; j < n; j++)
			 if (P[i][j] != 0 && (i != j) && (i != j-1) && (i != j+1))
				 return 0;
	return 1;
}
/////////////////////////////////////////////
void gauss(const float(*P)[MAXSIZE], float *b, unsigned int n)
{
	if (P == NULL || b == NULL || n <= 0 || n > MAXSIZE || !is_3diag(P, n))
	{
		cout << '!';
		return;
	}
    
    unsigned int i, j;
	float A[MAXSIZE][MAXSIZE];
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
			A[i][j] = P[i][j];
	
	for (i = 0; i < n; i++)
	{
		if(A[i][i] == 0)
		{
			cout << '?';
			return;
		}
		else
		{
			A[i][i+1] = A[i][i+1]/A[i][i];
		    float c = A[i][i];
            A[i][i] = 1;
			b[i] = b[i]/c;			
		}
		A[i+1][i+1] = A[i+1][i+1] - A[i+1][i]*A[i][i+1];
		b[i+1] = b[i+1] - b[i]*A[i][i+1];
		A[i+1][i] = 0;
	}
    flout(P, n);
	cout << endl << endl;
	flout(A, n);

	cout << endl;
	for (i = 0; i < n; i++)
		cout << b[i] << endl;
}
//////////////////////////////////////////////////////////////////
void trans(float(*A)[MAXSIZE], unsigned int n)
{
   if (n == 0)
       return;
   float buf;
   int i, j;

   for (i = 0; i < n; i++)
	   for (j = 0; j < i; j++)
	   {
		   buf = A[i][j];
		   A[i][j] = A[j][i];
		   A[j][i] = buf;
	   }
}
///////////////////////////////////////////////////////////////////
float vmult(float *x, float *y, unsigned int n)
{
   if (n == 0)
	   return 0;
   float result = 0;
   int i;
   for (i = 0; i < n; i++)
	   result = result+x[i]*y[i];
   return result;
}
////////////////////////////////////////////////////////////////////
void mmult(float (*A)[MAXSIZE], float (*B)[MAXSIZE], float (*C)[MAXSIZE], unsigned int n, unsigned int m, unsigned int k)
{
	if (n == 0 || n > MAXSIZE || m == 0 || m > MAXSIZE || k == 0 || k > MAXSIZE)
		return;	
	int i, j, e;

	for (i = 0; i < n; i++)
		for (j = 0; j < k; j++)
			C[i][j] = 0;

	for (i = 0; i < n; i++)
		for (j = 0; j < k; j++)
			for (e = 0; e < m; e++)
				C[i][j] = C[i][j] + A[i][e]*B[e][j];
	return;
}
////////////////////////////////////////////////////////////////////////
void bernstein(float (*N)[MAXSIZE], unsigned int n)
{
	if (n == 0 || n > MAXSIZE-1)
		return;
    int i, j;
	for (i = 0; i < n+1; i++)
		for (j = 0; j < n+1; j++)
		{
			if (i + j > n)
				N[i][j] = 0;
			else 
                N[i][j] = comb(n, j)*comb(n, n-i)*power(-1, n-i-j);
		}
		
}
////////////////////////////////////////////////////////////////////////
void flout(const float *P, unsigned int n)
{
	if (n == 0 || n > MAXSIZE)
		return;
	int i;
	for (i = 0; i < n; i++)
		cout << P[i] << "   "; 
}
/////////////////////////////////////////////////////////////////////////////
float getel(float(*A)[MAXSIZE], unsigned int order1, unsigned int order2, float t, float u)
{ 
   if (A == NULL || order1 == 0 || order1 > MAXSIZE 
	   || order2 == 0 || order2 > MAXSIZE || t < 0 || t > 1 || u < 0 || u > 1)
   return 0;

   float T[MAXSIZE][MAXSIZE] = {{0}};
   float U[MAXSIZE][MAXSIZE] = {{0}};
   float N[MAXSIZE][MAXSIZE] = {{0}};
   float M[MAXSIZE][MAXSIZE] = {{0}};

   float A1[MAXSIZE][MAXSIZE] = {{0}};
   float A2[MAXSIZE][MAXSIZE] = {{0}};
   bernstein(N, order1);
   bernstein(M, order2);
   int i;

   
   for (i = 0; i <= order1; i++)
	   T[0][i] = power(t, i);
   for (i = 0; i <= order2; i++)
       U[i][0] = power(u, i);
   
   mmult(T, N, A1, 1, order1+1,order1+1);   
   mmult(A1, A, A2, 1, order1+1, order2+1);
   mmult(A2, M , A1, 1, order2+1, order2+1);
   mmult(A1, U, A2, 1, order2+1, 1);
   return A2[0][0];
}