Решение инженерных задач обработки массивов

Размещено на http://www.allbest.ru/

Введение

Цель курсовой работы: закрепление знаний и умений по алгоритмизации и программированию на языке Си с использованием функций, процедур и различных сложных типов данных, в том числе динамических массивов, структур и объединений.

Назначение и область применения программы: программа будет использоваться в учебном процессе для решения инженерных задач обработки массивов, путём её включения в программы пользователей.

1. Задание на курсовую работу

1.1 Содержательное описание задачи

Для первой задачи даны три функции , и . Нужно будет найти элементы матрицы A по формуле

где x=f(i,j) - аргумент функции , a,b - пределы интегрирования функции .

Функция представляет собой арифметическую функцию, проблем с ее вычислением в принципе не должно возникнуть.

Функцию f2 следует продифференцировать.

Функция f3 есть подынтегральное выражение, которое является тригонометрическим выражением, вычисление будет производиться по формуле

a, b - нижний и верхний интеграл соответственно

К моменту выполнения второй задачи будет сформирована матрица. Задача состоит в том, чтобы сформировать вектор, состоящий из наибольших среди отрицательных элементов i-го столбца.

При решении первой задачи получим квадратную матрицу, т.е. матрицу. a которой число строк равно числу столбцов.

Третья задача представляет собой набор матричных операций. Необходимо перемножить три операнда, представленных в виде особого вида матрицы или вектора, а также некоторых действий над ними.

Рассмотрим эти операции.

Сначала нужно получить вектор, состоящий из обратных элементов вектора, полученного во второй части.

Вторым операндом будет квадрат разности исходной и транспонированной исходной матриц

Произведением матрицы Am*n = (aij) на матрицу Bn*p = (bjk) называется матрица Cm*p = (cik) такая, что

т.е. элемент i-й строки и k-го столбца матрицы произведения C равен сумме произведений элементов i-й строки матрицы A на соответствующие элементы k-го столбца матрицы B.

В качестве 3 операнда будет 1/D - вектор, составленный из обратных элементов главной диагонали матрицы А.

Матрица, полученная из данной заменой каждой её строки столбцом с тем же номером, называется матрицей транспонированной к данной. Обозначается AT.

В четвёртой задаче надо произвести стандартные арифметические действия над элементами матрицы, сформированной в первой задаче.

1.2 Математическая постановка задачи

Задание состоит из 4-х задач:

1.- формирование элементов матрицы A с помощью функций.

2. - формирование вектора X из элементов матрицы A,

3. -матричные операции: Z =

4. - комплексное преобразование массивов

Y= +

1.3 Интерфейс ввода/вывода

Данные будем вводить с клавиатуры, а результаты в файл.

1.4 Технические требования к программе

Программа будет выполняться под оболочкой DOS.

2. ОПИСАНИЕ АЛГОРИТМА

2.1 Расчетные формулы

1 Часть. , b=i+j, a=2,

x= i j+3/i

2 Часть.

3 Часть. Z =

4 Часть Y= +

2.2 Описание переменных

Наименование переменной	Тип переменной	Обозначение	Возможные значения
		В алгоритме	В программе
Входные переменные Размерность матрицы	целый	n	n	n>0
Выходные данные 1. Матрица А 2. Вектор X 3. Компл. преобр. массивов Y 4. Результат матр. операций	вещ. массив вещ. массив вещ. вещ.	A = {aij} X = {xi} Y Rez	a[i][j] x[i] y rmo	любые любые любые любые
Промежуточные переменные 1. Номер строки 2. Номер столбца 3. Матрица, возвед. в квадрат 4.Транспонированная матрица 5. 1/X - строка 7. Аргумент функции 8. 1/D - столбец 9.Нижний предел интегриров. 10.Верхний предел интегриров 11. Разность матриц	целый целый вещ. массив вещ. массив вещ. массив вещ. вещ. массив. вещ .вещ. вещ. массив	i j A2 = {aij} AТ = {aij} nv= {nvij} x D= {Di} a b razn= {raznij}	i j a2[i][j] At[i][j] nv[i][j] x d[i] a b razn[i][j]	1,2,...n 1,2,…n любые любые 0 или 1 любые любые любые любые любые

Структура программы

2.4 Сообщения программы

Программа выведет только одно сообщение “Введите размерность.n = ”

Также программы выведет вектор X цветными буквами.

3. ОПИСАНИЕ ПРОГРАММЫ

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <math.h>

//-------------------------------------------------

typedef struct{

unsigned cl:4;

unsigned fon:3;

unsigned bl:1;

} Att;

//-------------------------------------------------

typedef union{

unsigned char cod;

Att att;

} Mix;

//-------------------------------------------------

Mix set_attr(int b,int fon,int col)

{

Mix a1;

a1.att.bl=b;a1.att.fon=fon;a1.att.cl=col;

return a1;

}

//-------------------------------------------------

typedef double (*fun)(double x);

//-------------------------------------------------

double prlog(double x)

{

return 1/(x*log(3));

}

//-------------------------------------------------

double log3(double x)

{

return log(x)/log(3);

}

//-------------------------------------------------

double logy(double x)

{

return log(3)/x;

}

//-------------------------------------------------

fun Tab_fun[2][2]={{&log3,&prlog},{&log, &log}};

fun Tab_integ[2][2]={{&log,&logy},{&cos,&sin}};

//-------------------------------------------------

double Integ(fun ff,double a, double b)

{

fun f1;int i;

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

if(Tab_integ[i][0]==ff)

f1=Tab_integ[i][1];

return((*f1)(b)-(*f1)(a));

}

//-------------------------------------------------

double Dif_fun(fun ff, double x)

{

fun f1;int i,j;

for(i=0;i<2;i++)if(Tab_fun[i][0]==ff)

f1=Tab_fun[i][1];

return (*f1)(x);

}

//-------------------------------------------------

void form_matr(double **a, int n){

int i, j;

for (i = 1.0; i <= n; i++){

for (j = 1.0; j <= n; j++)

a[i-1][j-1]=tan(M_PI*(8.25+double(i+j)/2.0))*Dif_fun(log3,double(i*j)+3.0/double(i))+Integ(cos,2.0,double(i+j)) ;

}

}

//-------------------------------------------------

void form_vect(double *x, double **a, int n)

{

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

{

x[i]=-10e20;

for(int j=0;j<n;j++)

{

if(a[j][i]<0)

{

if(a[j][i]>x[i])

x[i]=a[j][i];

}

}

}

}

//-------------------------------------------------

void print_matr(double **a, int n, FILE *F)

{

int i, j;

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

{

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

{

fprintf(F, "%10.5f ",a[i][j]);

}

fprintf(F, "\n");

}

}

//-------------------------------------------------

void print_vect(double *x, int n, FILE *F)

{

int i;

Mix A1;

A1=set_attr(0,RED,YELLOW);

textattr(A1.cod);

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

{

fprintf(F, "%10.5f ", x[i]);

}

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

{

cprintf("%10.5f ", x[i]);

}

printf("\n");

}

//-------------------------------------------------

void Transpon(double **At, double **a, int n){

int i, j;

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

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

At[i][j] = a[j][i];

}

}

//-------------------------------------------------

void sqrM(double **a2, double **a, int n){

int i,j,k;

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

{

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

{

a2[i][j] = 0.0;

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

a2[i][j] += a[i][k] * a[k][j];

}

}

}

//-------------------------------------------------

void razn_matr(double **a1, double **a2, double **razn, int n) {

int i, j;

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

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

razn[i][j] = a1[i][j] - a2[i][j];

}

//-------------------------------------------------

void umnozh_vm(double **a,double *v,double *nv,int n)

{

double s;

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

{ s=0;

for(int j=0;j<n;j++)

s=s+v[j]*a[i][j];

nv[i]=s;

}

}

//-------------------------------------------------

double umnozh_sst(double *str,double *stl,int n)

{

double c;

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

c=c+str[i]*stl[i];

return c;

}

//-------------------------------------------------

double **GetMemoryMatr(int n)

{

int i;

double **a;

a = (double **)malloc(n*sizeof(double *));

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

a[i] = (double *)malloc(n*sizeof(double));

return a;

}

//-------------------------------------------------

void FreeMemoryMatr(double **a, int n)

{

int i;

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

free(a[i]);

free(a);

}

//-------------------------------------------------

double *GetMemoryVect(int n){

double *v;

v = (double *)malloc(n*sizeof(double));

return v;

}

//-------------------------------------------------

int Fact(int x)

{

int s=1;

for(int i=1;i<=x;i++)

s=s*i;

return s;

}

//-------------------------------------------------

void FreeMemVect(double *v)

{

free(v);

}

//-------------------------------------------------

double GetY(double **a,double *x,int n)

{

double min,p1,p2,c;

int i,k;

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

{

min=10e19;

c=1;

for(k=i+1;k=0;k--)

{

if (a[i][k-1]<0)

c=c*a[i][k-1];

}

if(c==1) c=0;

if(c<min)

min=c;

}

p1=min;

double S=0;

for(k=1;k<n;k+=2)

{

S=S+pow(x[k],Fact(k+1)/(k+1));

}

p2=S;

printf("%f %f",p1,p2);

return p1+p2;

}

//-------------------------------------------------

void Get1X(double *x, double *x1, int n)

{

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

x1[i]=1.0/x[i];

}

//-------------------------------------------------

void GetD(double **a,double *d, int n)

{

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

d[i]=1.0/a[i][i];

}

//-------------------------------------------------

void main()

{

clrscr();

double **a,**razn,*x,*x1,**a2,**At,rmo,*d,*nv;

FILE *fo=fopen("d:/res.txt", "w");;

int n;

printf("Введите размерность n=");

scanf("%d",&n);

a=GetMemoryMatr(n);razn=GetMemoryMatr(n);

a2=GetMemoryMatr(n);At=GetMemoryMatr(n);

nv=GetMemoryVect(n);x=GetMemoryVect(n);x1=GetMemoryVect(n);

d=GetMemoryVect(n);d=GetMemoryVect(n);

fprintf(fo,"Матрица А:\n\n");

form_matr(a,n);

print_matr(a,n,fo);

//Part II

fprintf(fo,"\nВектор X:\n\n");

form_vect(x,a,n);

print_vect(x,n,fo);

Get1X(x,x1,n);

fprintf(fo,"\n\nВектор1/X:\n\n");

print_vect(x1,n,fo);

GetD(a,d,n);

fprintf(fo,"\n\nСтолбец 1/D:\n\n");

print_vect(d,n,fo);

//Part III

Transpon(At,a,n);

fprintf(fo,"\n\nТранспонированная матрица: A\n");

print_matr(At,n,fo);

razn_matr(At,a,razn,n);

fprintf(fo,"\n\nРазность транспон. и исходной матрицы:\n\n");

print_matr(razn,n,fo);

sqrM(a2,razn,n);

fprintf(fo,"\nПолученная разность в квадрате:\n\n");

print_matr(a2,n,fo);

umnozh_vm(a2,x1,nv,n);

fprintf(fo,"\nУмножение вектора 1/X на разность в квадрате2:\n\n");

print_vect(nv,n,fo);

rmo=umnozh_sst(nv,d,n);

fprintf(fo,"\n\nРезультат матричных операций (константа): %f\n\n", rmo);

double Y=GetY(a,x,n);

fprintf(fo,"\n\nРезультат комплексных преобразований:\n\nY = %f",Y);

FreeMemoryMatr(a,n);FreeMemoryMatr(razn,n);

FreeMemoryMatr(a2,n);FreeMemoryMatr(At,n);

FreeMemVect(x);FreeMemVect(x1);

FreeMemVect(nv);FreeMemVect(d);

getchar();getchar();

fcloseall();

}

4. КОНТРОЛЬНЫЙ ПРИМЕР

Все расчеты проведем в MathCad'е.

,

То, что вывела программа в файл при размерности n=2:

Матрица А:

0.22756 -0.95023

-1.02825 -1.50060

Вектор X:

-1.02825 -0.95023

Вектор 1/X:

-0.97253 -1.05238

Вектор 1/D:

4.39445 -0.66640

Транспонированная матрица: A

0.22756 -1.02825

-0.95023 -1.50060

Разность транспон. и исходной матрицы:

0.00000 -0.07802

0.07802 0.00000

Полученная разность в квадрате:

-0.00609 0.00000

0.00000 -0.00609

Умножение вектора 1/X на разность в квадрате2:

0.00592 0.00641

Результат матричных операций (константа): 0.021746

Результат комплексных преобразований:

Y = -0.950225

Как видно, программа все шаги выполнила верно, это подтверждено ручным расчетом.

ВЫВОД

В результате проделанной курсовой работы можно сделать следующие вывод: разработана корректно работающая программа, способная решать некоторые инженерные задачи.

Размещено на Allbest.ru