немогу найти, почему висьнет программа...

-----------------------------------------------------------------------
// Отчёная программа за 2 семестр по предмету информатика
//-----------------------------------------------------------------------
Задание №1 (214)
//-----------------------------------------------------------------------
Пусть a0=Cos(1)*Cos(1), a1=-Sin(1)*sin(1),
ak=2*a(k-2)-a(k-1), k=2,3....
Найти сумму квадратов(от 1 до N)!
//-----------------------------------------------------------------------
Задание №2 (717а)
//-----------------------------------------------------------------------
// Две треугольные матрицы А и В порядка n заданны в виде
// последовотельности (n+1)n\2 чисел: сначала идет n элементов
// первой строки,затем n-1 элементов второй строки, начиная со второго
// элемента, и т.д. (из последней n строки берется только n элемент)
//
// Получить в аналогичном виде:
// матрицу А*В
//-----------------------------------------------------------------------
#include "stdafx.h"// подключается файл stdafx.h
#include <stdio.h>//Функции ввода - вывода для стандартных потоков
#include <conio.h> //Функции для работы с терминалом в текстовом режиме
#include <ctype.h>//Функции и макросы проверки и преобразования символов
#include <stdlib.h>//Функция для работы с динамической памятью
#include <string.h> //Функция работы со строками
#include <math.h>//функция для работы с математическими функциями
#include <malloc.h>
#include "locale.h"//Функция для подключения русского языка
 
void zad_rec();  // задание рекурсии
void zad_matrica();  //задание матрица
void inform_rec();  //онформация рекурсия
void inform_matrica(); //информация матрица
int input(int,char,char);//ввод размерности
double input_massiv1(int,double **);//ввод массива а
double input_massiv2(int,double **);//ввод массива в
void output(int,char, char, char,double , int, double**, double **, double **);//вывод
double recursia(int);//рекурсия
double matrix(int,double **, double**, int, double **, double **,double **);//матрица
int zashita_rec();// Функция защиты при вводе N в рекурсии
int zashita_matrica();// Функция защиты при вводе N в матрице
int zashita_elem();// Функция защиты при вводе элементов в матрице
void main()
{
   setlocale(LC_ALL,"Russian");
 
   char c='\0';
   char typeTask='\0',//тип задания
   typeInput='\0',//способ ввода данных
   typeOutput='\0';//способ вывода данных
   int N=20;
   int Ab=0; //матрица
   double itog=0;//рекурсия
   double **A,**A1;
   double **B, **B1;
   double **C;
   int i, j;
   int k=2;
 
 
   do
{
   //textbackground(BLACK);
   system("cls");
   c=0;
   printf("1. Выбор задания\n");
   printf("2. Ввод данных\n");
   printf("3. Расчет\n");
   printf("4. Вывод результата\n");
   printf("5. Информация\n");
   printf("6. Текст задания\n");
   printf("7. Выход\n");
   printf("Выберите пункт меню:\n");
   while ((c = _getch()) < '1'|| c > '7')
   printf("\rВыберите пункт меню: \n");
   switch(c)
   {
     // ВЫБОР ЗАДАНИЯ
     case '1':
     system("cls");
     c = '\0';
     printf("1. Матрицы\n");
     printf("2. Рекурсия\n");
     printf("Выберите тип задания >>> \n");
     while ((c = _getch()) < '1' || c > '2')
     printf("\rВыберите тип задания >>> \n");
     typeTask = c;// Флаговая переменная определяющая тип задания
     break;
    // ВВОД ДАННЫХ
    case '2':
      system("cls");
      c = '\0';
      switch(typeTask)
      {
        case '1':
        system("cls");
        if(typeTask == '2' || typeTask == '1')
        {
          printf("1. С клавиатуры\n");
          printf("2. Из файла\n");
          printf("Выберите способ ввода данных >>> \n");
          while ((c = _getch()) < '1' || c > '2')
          printf("\rВыберите способ ввода данных >>>\n ");
          typeInput = c;/* Флаговая переменная определяющая способ ввода данных */
          N=input(N,typeInput,typeTask);
          {
            A=(double**)malloc(N*sizeof(double*));
            B=(double**)malloc(N*sizeof(double*));
            for (i=0; i<N; i++)
              for (j=0; j<N; j++)
                A[i]=(double*)realloc(0,N*sizeof(double));
              B[i]=(double*)realloc(0,N*sizeof(double));
              A=input_massiv1(N , A);
              B=input_massiv2(N , B);
          }
       }
       break;
       case '2':
         system("cls");
         if(typeTask == '2' || typeTask == '1')
         {
            printf("1. С клавиатуры\n");
            printf("2. Из файла\n");
            printf("Выберите способ ввода данных >>> \n");
            while ((c = _getch()) < '1' || c > '2')
              printf("\rВыберите способ ввода данных >>>\n ");
            typeInput = c;/* Флаговая переменная определяющая способ ввода данных */
            N=input(N,typeInput,typeTask);
          }
          break;
          default:
            printf("Ошибка: задание не выбрано.");
            printf("\nНажмите любую клавишу для продолжения...\n");
            _getch();
       }
       break;
      // РАСЧЁТ
      case '3':
        system("cls");
        c = '\0';
        switch(typeTask)
        {
          case '1':
          system("cls");
          if(typeInput=='1'||typeInput=='2')
          {
             A1=matrix(N, A, B, k, A1, B1, C);
             B1=matrix(N, A, B, k, A1, B1, C);
             C=matrix(N, A, B, k, A1, B1, C);
                         printf("Расчет произведен.");
                          printf("\nНажмите любую клавишу для продолжения...\n");
             _getch();
          }
          else
          {
            printf("Ошибка: данные не введены.");
            printf("\nНажмите любую клавишу для продолжения...\n");
            _getch();
          }
          break;
                  case '2':
                        system("cls");
                        if(typeInput=='1'||typeInput=='2')
                        {
                          itog=recursia(N);//rec=0.75 n=2 y=0
                            printf("Расчет произведен.");
                            printf("\nНажмите любую клавишу для продолжения...\n");
                            _getch();
                        }
                        else
                        {
                            printf("Ошибка: данные не введены.");
                            printf("\nНажмите любую клавишу для продолжения...\n");
                            _getch();
                        }
                        break;
                        default:
                            printf("Ошибка: задание не выбрано.");
                            printf("\nНажмите любую клавишу для продолжения...\n");
                            _getch();
                        }
                        break;
                /* ВЫВОД РЕЗУЛЬТАТА */
                case '4':
                    system("cls");
                    if(itog==NULL && k==NULL)
                    {
                        printf("Ошибка: расчет не произведен.");
                        printf("\nНажмите любую клавишу для продолжения...\n");
                        _getch();
                    }
                    else
                    {
                        c = '\0';
                        printf("1. На экран\n");
                        printf("2. В файл\n");
                        printf("Выберите способ вывода результата >>> ");
                        while ((c = _getch()) < '1' || c > '2')
                        printf("\rВыберите способ вывода результата >>> ");
                        typeOutput = c;/* Флаговая переменная определяющая способ вывода данных */
                        output(N, typeInput, typeTask, typeOutput, itog , k, A1, B1, C);
 
                    }
                    break;
                    // ИНФОРМАЦИЯ
                    case '5':
                    system("cls");
                    {
                        c = '\0';
                        switch(typeTask)
                        {
                            case '1':
                                system("cls");
                                inform_matrica();
                            break;
                            case '2':
                                system("cls");
                                inform_rec();
                            break;
                            default:
                                printf("Задание не выбрано");
                        }
                        printf("\nНажмите любую клавишу для продолжения...\n");
                        _getch();
                        break;
                    }
                    /* ТЕКСТ ЗАДАНИЯ */
                    case '6':
                        system("cls");
                        c = '\0';
                        switch(typeTask)
                        {
                            case '1':
                                system("cls");
                                zad_matrica();
                            break;
                            case '2':
                                system("cls");
                                zad_rec();
                            break;
                            default:
                                printf("Задание не выбрано");
                        }
                        printf("\nНажмите любую клавишу для продолжения...\n");
                        _getch();
                        break;
                /* ВЫХОД */
                case '7':
                    system("cls");
                    printf("Выйти?\r\n");
                    printf("1. Да\n");
                    printf("2. Нет\n");
                    printf(">>>\n");
                    while ((c = _getch()) != '1' && c != '2')
                    printf("\r>>> \n");
                    if (c == '1')
                    {
                        c = '7';
                    }
                    else
                    {
                        c = '\0';
                    }
                break;
            }
        }
        while(c!='7');
    }
void inform_matrica()
{
    printf("\n\t\tИнформация о задании № 1:\n");
    printf(" Задание по матрицам № 717а.\n");
    printf(" Версия 1.2\n");
    printf(" 2009 год\n");
    printf(" Разработчик : \n");
    printf(" студентка ВятГУ гр. ПС-11\n");
}
void inform_rec()
{
    printf("\n\t\tИнформация о задании № 2:\n");
    printf(" Задание по рекурсии № 214.\n");
    printf(" Версия 1.2\n");
    printf(" 2009 год\n");
    printf(" Разработчик : \n");
    printf(" студентка ВятГУ гр. ПС-11\n");
}
void zad_matrica()
{
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t Задание(матрица): ");
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t \n");
    printf("\t Две треугольные матрицы А и В порядка n заданны в виде \n");
    printf("\t последовотельности (n+1)n\2 чисел: сначала идет n элементов \n");
    printf("\t первой строки,затем n-1 элементов второй строки, начиная со второго \n");
    printf("\t элемента, и т.д. (из последней n строки берется только n элемент).\n");
    printf("\t Получить в аналогичном виде: \n");
    printf("\t матрицу А*В. \n");
    printf("\t \n");
    printf("\n\t---------------------------------------------------------------------");
}
void zad_rec()
{
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t Задание(рекурсия): ");
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t ");
    printf("\n\t Пусть a0=Cos(1)*Cos(1), a1=-Sin(1)*sin(1), ");
    printf("\n\t ak=2a(k-1)-a(k-2), k=2,3.... ");
    printf("\n\t найти сумму квадратов(от 1 до N) ! ");
    printf("\n\t ");
    printf("\n\t---------------------------------------------------------------------");
}
 
/* ФУНКЦИЯ ДЛЯ ВВОДА N */
 
int input(int N ,char typeInput , char typeTask)
{
    FILE *W;
    char file[256];
    int const maxNat=10;//ограничение на размерность матрицы
    int const maxNatt=80;//ограничение на рекурсию
if(typeTask == '2')//ввод данных для рекурсии
{
    if(typeInput == '1')//с клавиатуры
    {
        system("cls");
        do
        {
            printf("\n\n\tВведите число N(1 ... %d) = ", maxNatt);
            N=zashita_rec();
            if (N>maxNatt)
            {
                printf("\n Вы ввели неправильное число.");
                printf("\n Нажмите любую клавишу.");
                _getch();
            }
        }
        while (N>maxNatt);
    }
    else//из файла
    {
        do
        {
            printf("\nУкажите путь к файлу:");
            scanf("%s",file);
            W = fopen(file,"r");
        }
        while(W==NULL);
        fscanf(W,"%d %f %f",N);
        fclose(W);
    }
}
else//ввод данных для матрицы
{
    if(typeInput == '1')//с клавиатуры
    {
        system("cls");
        do
        {
            printf("\t Введите размерность массива ( 1 ... %d ) : ",maxNat);
            N=zashita_matrica();
            if (N>maxNat)
            {
                printf(" Вы ввели неправильное число.");
                printf("\n Нажмите любую клавишу.\n");
                _getch();
            }
        }
        while (N>maxNat);
    }
    else//из файла
    {
        do
        {
            printf("\nУкажите путь к файлу:");
            scanf("%s",file);
            W = fopen(file,"r");
        }
        while(W==NULL);
        fscanf(W,"%d",N);
        fclose(W);
    }
}
return N;
}
/* ФУНКЦИЯ ДЛЯ ВВОДА ЭЛЕМЕНТОВ МАССИВА */
double input_massiv1(int N ,double **A)
{
    int i,j;
    printf(" Заполните массив A:\n");
 
for ( i=0; i<N; i++)
    for ( j=0; j<N-i; j++)
    {
        printf ("A[%d][%d] = ",i,j);
        A[i][j]=zashita_elem();
    }
    return **A;
}
double input_massiv2(int N ,double **B)
{
    int i,j;
    printf(" Заполните массив B:\n");
 
for ( i=0; i<N; i++)
    for ( j=0; j<N-i; j++)
    {
        printf ("B[%d][%d] = ",i,j);
        B[i][j]=zashita_elem();
    }
    return **B;
}
/* ФУНКЦИЯ ДЛЯ ВЫВОДА ДАННЫХ */
 
void output(int N,char typeInput, char typeTask, char typeOutput,double itog, int k, double **A1, double **B1, double **C)
{
    int i, j;
    FILE *W;
    char file[256];
    if(typeTask == '2')//вывод для рекурсии
    {
        if(typeOutput == '1')//на экран
        {
            printf("\n\tПри N = %d результат равен : %.15lf",N,itog);
            printf("\nНажмите любую клавишу для продолжения...\n");
            _getch();
        }
        else//в файл
        {
            printf("\nУкажите путь к файлу, в который хотите сохранить результат: ");
            scanf("%s",&file);
            W = fopen(file,"a++");
            fprintf(W,"\n\tПри N = %d результат равен : %.15lf",N,itog);
            fclose(W);
            printf("Результат сохранен");
            printf("\nНажмите любую клавишу для продолжения...");
            _getch();
        }
    }
    else//вывод для матрицы
    {
    if(typeOutput == '1')//на экран
    {
        printf("Введен массив A, размерности %d",N);
        printf("\n");
        for (i=0;i<N;i++)
        {
            for (j=0;j<(N-i);j++)
            {
                printf("%g ",A1[i][j]);
            }
        printf("\n");
    }
    printf("Введен массив B, размерности %d",N);
    printf("\n");
    for (i=0;i<N;i++)
    {
        for (j=0;j<(N-i);j++)
        {
            printf("%g ",B1[i][j]);
        }
        printf("\n");}
        printf(" Решение:");
        printf("Массив А*В\n");
        for (i=0;i<N;i++)
        {
            for (j=0;j<(N-i);j++)
            {
                printf("%g ",C[i][j]);
            }
            printf("\n");}
        printf("\nНажмите любую клавишу для продолжения...");
        _getch();
    }
    else//в файл
    {
        printf("\nУкажите путь к файлу, в который хотите сохранить результат: ");
        scanf("%s",&file);
        W = fopen(file,"a++");
        fprintf(W,"\nОтвет(матрица):\nAb(n=%d):\n",N);
        for(i=0;i<N;i++)
            //fprintf(W,"%d\t",t);
            fclose(W);
        printf("Результат сохранен");
        printf("\nНажмите любую клавишу для продолжения...");
        _getch();
    }
 }
}
double recursia(int N)
{
    static int z=0;//к-элемент
    static double x=1.5;//значение при cos и sin
    static double a,b,c,d;
    static double a0,a1,a2,a3,a4;//значение элемета
    static double itog=0;//результат
    if(z==N)    
    {
        z=0,a=0,a0=0,a1=0,a2=0,a3=0,a4=0;
        b=0,c=0,d=0;
    }
    else
    {
        if(z==0)
    { itog=0;
        a0=(cos (x) * cos (x));
        a=a0;
        itog=a0*a0;
        ++z;
    }
    else{
    if(z==1)
    {
        a1=-(sin (x) * sin (x));
        b=a1;
        itog+=b*b;
        ++z;
    }else{
    if(z==2)
    {
         a2=2*b-a;
        itog=itog+(a2*a2);
        c=a2;
        ++z;
    }else{
    if(z==3)
    {
        a3=2*c-b;
        itog=itog+(a3*a3);
        d=a3;
        ++z;
    }else{
       a4=2*d-c;
        itog=itog+(a4*a4);
        c=d;
        d=a4;
        ++z;
    }
  }
 }
}
recursia(N);
}
return itog;
}
/* МАТРИЦА */
//int CheckMagic(double **A, int N);
double matrix(int N, double **A, double **B, int k, double **A1, double **B1,double **C)
{int i,j;
    A1=(double**)malloc(N*sizeof(double*));
    B1=(double**)malloc(N*sizeof(double*));
    for (i=0; i<N; i++)
    for (j=0; j<N; j++)
        A1[i]=(double*)realloc(0,N*sizeof(double));
    B1[i]=(double*)realloc(0,N*sizeof(double));
    for (i=0;i<N;i++)
    {
        for (j=0;j<(N);j++)
        {
            A1[i][j]=0;
            B1[i][j]=0;
        }
    }
    A=input_massiv1(N,A);
    B=input_massiv2(N,B);
    for (i=0;i<N;i++){
        for (j=0;j<(N);j++)
        {
            if ((i+j+1)<=N)
            A1[i][j]=A[i][j];
        }
    }
for (i=0;i<N;i++)
{    
    for (j=0;j<(N);j++)
    {
       if ((i+j+1)<=N)
      {
          B1[i][j]=B[i][j];
        }
}}
for (i=0;i<N;i++)
  for (j=0;j<(N-i);j++)
    {
        for(C[i][j]=0,k=0;k<N;k++)
            C[i][j]+=A1[i][k]*B1[k][j];
    }
    return **A1,**B1,**C;
}
/* ЗАЩИТА */
/* Функция защиты при вводе N в рекурсии */
int zashita_rec()
{
    int k=0,in=0;
    char ch=0,mas[20];
    do
    {
      ch=_getch();
        if(ch>=48 && ch<=58 && k<2)
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
    }
    in=atoi(mas);
   }
   while(ch!=13 ||in==0);
   printf("\n");
   return in;
}
 
/* Функция защиты при вводе N в матрице */
int zashita_matrica()
{
    int k=0,in=0;
    char ch=0,mas[20];
    do
    {
        ch=_getch();
        if(ch>=48 && ch<=58 && k<2)
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
        }
        in=atoi(mas);
    }
    while(ch!=13 ||in==0);
    printf("\n");
    return in;
}
/* Функция защиты при вводе элементов в матрице */
int zashita_elem()
{
    int k=0,in=0;
    char ch=0,mas[20];
    do
    {
        ch=_getch();
        if(ch>=48 && ch<=58 && k<3)
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
        }
        in=atoi(mas);
    }
    while(ch!=13 ||in==0);
    printf("\n");
    return in;
}

#include "stdafx.h" // подключается файл stdafx.h 
#include <stdio.h>  //Функции ввода - вывода для стандартных потоков
#include <conio.h>  //Функции для работы с терминалом в текстовом режиме 
#include <ctype.h>  //Функции и макросы проверки и преобразования символов
#include <stdlib.h> //Функция для работы с динамической памятью
#include <string.h> //Функция работы со строками  
#include <math.h>   //функция для работы с математическими функциями
#include <malloc.h>
#include "locale.h" //Функция для подключения русского языка
 
void zad_rec();                     // задание рекурсии
void zad_matr();                    //задание матрица
void inform_rec();                  //информация рекурсия
void inform_matr();             //информация матрица
int input_rec(int,char,char);               //ввод N в рекурсии (с клавиатуры или из файла)
int input_matr(int,char,char);              //ввод N в матрице (с клавиатуры)
double input_matr2(int,double**,double**);          //ввод элементов матрицы (с клавиатуры)
void output_rec(int,char ,char,char,double);        //вывод численного результата (рекурсия)
void output_matr(int,char,char,char, double**,double**,double**);   //вывод результата (матрица)
double recursia(int);                   
double matrix(int,double**,double**,double**, double**, double**);              
int zashita_rec();          // Функция защиты при вводе N в рекурсии 
int zashita_matr();         // Функция защиты при вводе N в матрице 
int zashita_elem();         // Функция защиты при вводе элементов в матрице 
 
/* ИНТЕРФЕЙС */
void main()
{
    setlocale(LC_ALL,"Russian");
    char c='\0';
    char typeTask='\0',     //тип задания
        typeInput='\0',     //способ ввода данных
        typeOutput='\0';    //способ вывода данных
    int N=15;       //размерность
    double itog=0;      //результат рекурсии
    double **A,**B,**D,**A1,**B1;       //двумерный массив
    int i; 
    int k=0;        //тип квадрата
    int t=0;        //ограничение на ввод элементов
 
    do
    {
        system("cls");
        c=0;
        printf("1. Выбор задания\n");       //меню для пользователя
        printf("2. Ввод данных\n");
        printf("3. Расчет\n");
        printf("4. Вывод результата\n");
        printf("5. Информация\n");
        printf("6. Текст задания\n");
        printf("7. Выход\n");
        printf("Выберите пункт меню:\n");
    
        while ((c = _getch()) < '1'|| c > '7')
            printf("\rВыберите пункт меню: \n");
 
        switch(c)
        {
        
        /* ВЫБОР ЗАДАНИЯ */
        case '1':               //выбор задания - матрица или рекурсия
            system("cls");
            c = '\0';
            printf("1. Матрицы\n");
            printf("2. Рекурсия\n");
            printf("Выберите тип задания >>> \n");
            while ((c = _getch()) < '1' || c > '2')
                printf("\rВыберите тип задания >>> \n");
            typeTask = c;       // Флаговая переменная определяющая тип задания
            break;
    
        /* ВВОД ДАННЫХ */
        case '2':   
            system("cls");
            c = '\0';
            switch(typeTask)
            {
            case '1':                           //если выбрана матрица
                system("cls");
                if(typeTask == '2' || typeTask == '1')
                {
                    printf("1. С клавиатуры\n");
                    printf("2. Из файла\n");
                    printf("Выберите способ ввода данных >>> \n");
                    while ((c = _getch()) < '1' || c > '2')
                        printf("\rВыберите способ ввода данных >>>\n ");
typeInput = c;  // Флаговая переменная определяющая способ ввода данных 
 
                    if(typeInput == '1')        //ввод матрицы с клавиатуры
                    {
                        N=input_matr(N,typeInput,typeTask);             //ввод размерности матрицы
                        {
                        A=(double**)malloc(N*sizeof(double*));
                        B=(double**)malloc(N*sizeof(double*));
                        A1=(double**)malloc(N*sizeof(double*));
                        B1=(double**)malloc(N*sizeof(double*));
                        D=(double**)malloc(N*sizeof(double*));
                        for (i=0; i<N; i++)
                                
                        {
                            A[i]=(double*)realloc(0,N*sizeof(double));
                            B[i]=(double*)realloc(0,N*sizeof(double));
                            A1[i]=(double*)realloc(0,N*sizeof(double));
                            B1[i]=(double*)realloc(0,N*sizeof(double));
                            D[i]=(double*)realloc(0,N*sizeof(double));
                        }
                        }
                        input_matr2(N,A,B);
                    }
                    else            //ввод матрицы из файла
                    {
                        int i;
                        FILE *fp;
                        char fname[30];
                        FILE *zadaniematrici;
                        char* file_name = "matr_vvod.txt";
                        printf("\n\n  Введите имя файла: ");
                        scanf("%s", &fname);
                        if ((fp = fopen(fname, "r")) == NULL)           //если введенный файл не найден
                        {
                            printf("\nТакого файла нет");
                            printf("\nДанные заносятся автоматически из файла matr_vvod.txt");
                            zadaniematrici = fopen( file_name, "r" );
                            
                            fscanf(zadaniematrici, "%d\n", &N);         //берётся переменная N из файла
                            {
                        A=(double**)malloc(N*sizeof(double*));
                        B=(double**)malloc(N*sizeof(double*));
                        A1=(double**)malloc(N*sizeof(double*));
                        B1=(double**)malloc(N*sizeof(double*));
                        D=(double**)malloc(N*sizeof(double*));
                        for (i=0; i<N; i++)
                                
                        {
                            A[i]=(double*)malloc(N*sizeof(double));
                            B[i]=(double*)malloc(N*sizeof(double));
                            A1[i]=(double*)malloc(N*sizeof(double));
                            B1[i]=(double*)malloc(N*sizeof(double));
                            D[i]=(double*)malloc(N*sizeof(double));
                        }
                        }
                            for (int i = 0; i < N; i++)
                            {        
                                for (int j = 0; j < (N-i); j++)
                                {
                                        fscanf(zadaniematrici, "%d ", &A[i][j]);
                                }
                            }
                            for (int i = 0; i < N; i++)
                            {        
                                for (int j = 0; j < (N-i); j++)
                                {
                                        fscanf(zadaniematrici, "%d ", &B[i][j]);
                                }
                            }
                        }               
                        else                                //если введеннный файл найден
                        {
                            fscanf(fp, "%d\n", &N);             //берётся переменная N из файла
                            {
                        A=(double**)malloc(N*sizeof(double*));
                        B=(double**)malloc(N*sizeof(double*));
                        A1=(double**)malloc(N*sizeof(double*));
                        B1=(double**)malloc(N*sizeof(double*));
                        D=(double**)malloc(N*sizeof(double*));
                        for (i=0; i<N; i++)
                                
                        {
                            A[i]=(double*)realloc(0,N*sizeof(double));
                            B[i]=(double*)realloc(0,N*sizeof(double));
                            A1[i]=(double*)realloc(0,N*sizeof(double));
                            B1[i]=(double*)realloc(0,N*sizeof(double));
                            D[i]=(double*)realloc(0,N*sizeof(double));
                        }
                        }
 
                            for (int i = 0; i < N; i++)
                            {
                                for (int j = 0; j < N; j++)
                                {
 
                                    fscanf(fp, "%d ", &A[i][j]);
                                }
                            }
                        }   
                        _getch();
                    }
 
 
                }
                break;
            case '2':                       //если выбрана рекурсия
                system("cls");
                if(typeTask == '2' || typeTask == '1')
                {
                    printf("1. С клавиатуры\n");
                    printf("2. Из файла\n");
                    printf("Выберите способ ввода данных >>> \n");
                    while ((c = _getch()) < '1' || c > '2')
                        printf("\rВыберите способ ввода данных >>>\n ");
                    typeInput = c;                          // Флаговая переменная определяющая способ ввода данных
                    N=input_rec(N,typeInput,typeTask);  //ввод N для рекурсии
                }
                break;
            default:
                printf("Ошибка: задание не выбрано.");
                printf("\nНажмите любую клавишу для продолжения...\n");
                _getch();
            }
            break;
 
        /* РАСЧЁТ */
        case '3':
            system("cls");
            c = '\0';
            switch(typeTask)
            {
            case '1':
                system("cls");
                if(typeInput=='1'||typeInput=='2')
                {
                    **A1=matrix(N, A, B, A1, B1, D);
                    **B1=matrix(N, A, B, A1, B1, D);
                    **D=matrix(N, A, B, A1, B1, D);                 
                    printf("Расчет произведен.");
                    printf("\nНажмите любую клавишу для продолжения...\n");                    
                    _getch();
                }
                else
                {
                    printf("Ошибка: данные не введены.");
                    printf("\nНажмите любую клавишу для продолжения...\n");
                    _getch();
                }
                break;
            case '2':
                system("cls");
                if(typeInput=='1'||typeInput=='2')
                {
                    itog=recursia(N);                       //вычисление результата рекурсивной функции
                    printf("Расчет произведен.");
                    printf("\nНажмите любую клавишу для продолжения...\n");    
                    _getch();
                }
                else
                {
                    printf("Ошибка: данные не введены.");
                    printf("\nНажмите любую клавишу для продолжения...\n");
                    _getch();
 
 
                }
                break;
            default:
                printf("Ошибка: задание не выбрано.");
                printf("\nНажмите любую клавишу для продолжения...\n");
                _getch();
            }
            break;
    
        /* ВЫВОД РЕЗУЛЬТАТА */
        case '4':   
                
            if (typeTask != '2' && typeTask != '1')
            {
                system("cls");
                printf("Ошибка: задание не выбрано.");
                printf("\nНажмите любую клавишу для продолжения...\n");
                _getch();
            }
            else
 
            {
                system("cls");
                c = '\0';
                if(itog==NULL && A==NULL)       //если данные не были введены
                {
                    printf("Ошибка: расчет не произведен.");
                    printf("\nНажмите любую клавишу для продолжения...\n");
                    _getch();
                }
                else
                {
                    if(typeTask == '2')     //если выбрана рекурсия
                    {
                        c = '\0';
                        system("cls");
                        printf("1. На экран\n");
                        printf("2. В файл\n");
                        printf("Выберите способ вывода результата >>> ");
                        while ((c = _getch()) < '1' || c > '2')
                                  printf("\rВыберите способ вывода результата >>> ");
                        typeOutput = c;                 
/* Флаговая переменная определяющая способ вывода данных */
                        output_rec( N,typeInput, typeTask, typeOutput, itog);       //вывод результата рекурсии
                    }               
                    else                //если выбрана матрица
                    {
                        c = '\0';
                        system("cls");
                        printf("1. На экран\n");
                        printf("2. В файл\n");
                        printf("Выберите способ вывода результата >>> ");
                        while ((c = _getch()) < '1' || c > '2')
 
                        printf("\rВыберите способ вывода результата >>> ");
                        typeOutput = c;                 
/* Флаговая переменная определяющая способ вывода данных */
                        output_matr(N, typeInput, typeTask, typeOutput,A1, B1, D);  //вывод результата решения о матрице
                    }
                }
            }
            break;
    
 
        /* ИНФОРМАЦИЯ */
        case '5':
            system("cls");
            {
                c = '\0';
                switch(typeTask)
                {
                case '1':
                    system("cls");
                    inform_matr();
                    break;
                case '2':
                    system("cls");
                    inform_rec();
                    break;
                default:
                    printf("Задание не выбрано");
                }
                printf("\nНажмите любую клавишу для продолжения...\n");
                _getch();
                break;
            }
 
        /* ТЕКСТ ЗАДАНИЯ */
        case '6':                   //вывод на экран текста задания
            system("cls");
            c = '\0';
            switch(typeTask)
            {
            case '1':
                system("cls");
                zad_matr();
                break;
            case '2':
                system("cls");
                zad_rec();
                break;
            default:
                printf("Задание не выбрано");
            }
            printf("\nНажмите любую клавишу для продолжения...\n");
            _getch();
            break;
    
        /* ВЫХОД */
        case '7':               //выход из программы
            system("cls");
            printf("Выйти?\r\n");
            printf("1. Да\n");
            printf("2. Нет\n");
            printf(">>>\n");
            while ((c = _getch()) != '1' && c != '2')
                printf("\r>>> \n");
            if (c == '1')       //если пользователь хочет выйти
            {
                c = '7';
            }
            else            //если пользователь хочет продолжить работу
            {
                c = '\0';
            }
        }
    }
while(c!='7');          //продолжать цикл до тех пор пока  c!='7'
}
 
void inform_matr()
{
    printf("\n\t\tИнформация о задании № 1:\n");
    printf(" Задание по матрицам № 717а.\n");
    printf(" Версия 1.2\n");
    printf(" 2009 год\n");
    printf(" Разработчик : Скопина Кристина,\n");
    printf(" студентка ВятГУ гр. ПС-11\n");
}
void inform_rec()
{
    printf("\n\t\tИнформация о задании № 2:\n");
    printf(" Задание по рекурсии № 214.\n");
    printf(" Версия 1.2\n");
    printf(" 2009 год\n");
    printf(" Разработчик : Скопина Кристина,\n");
    printf(" студентка ВятГУ гр. ПС-11\n");
}
void zad_matr()
{
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t                    Задание(матрица):                                ");
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t                                                                   \n");
    printf("\t        Две треугольные матрицы А и В порядка n заданны в виде       \n");
    printf("\t     последовотельности (n+1)n\2 чисел: сначала идет n элементов     \n");
    printf("\t первой строки,затем n-1 элементов второй строки, начиная со второго \n");
    printf("\t   элемента, и т.д. (из последней n строки берется только n элемент).\n");
    printf("\t                    Получить в аналогичном виде:                     \n");
    printf("\t                          матрицу А*В.                               \n");
    printf("\t                                                                     \n");
    printf("\n\t---------------------------------------------------------------------");
}
void zad_rec()
{
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t                        Задание(рекурсия):                           ");
    printf("\n\t---------------------------------------------------------------------");
    printf("\n\t                                                                     ");
    printf("\n\t             Пусть a0=Cos(1)*Cos(1), a1=-Sin(1)*sin(1),              ");
    printf("\n\t                 ak=2a(k-1)-a(k-2),    k=2,3....                     ");
    printf("\n\t                найти сумму квадратов(от 1 до N) !                   ");
    printf("\n\t                                                                     ");
    printf("\n\t---------------------------------------------------------------------");
}
/* ФУНКЦИЯ ДЛЯ ВВОДА N РЕКУРСИИ ( с клавиатуры или из файла )*/
 
int input_rec(int N ,char typeInput , char typeTask)
{
    int const maxNatt=80;       //ограничение на рекурсию
    if(typeInput == '1')        //с клавиатуры
    {
        system("cls");
        do
        {
            printf("\n\n\tВведите число N(1 ... %d) = ", maxNatt);
            N=zashita_rec();            //защита на ввод числа N
            if (N>maxNatt)
            {
                printf("\n Вы ввели неправильное число.");
                printf("\n Нажмите любую клавишу.");
                _getch();
            }
        }
        while (N>maxNatt);          //повторять ввод до тех пор, пока
        _getch();           //число не будет входить в определенный промежуток    
    }
    else        //из файла
    {
        FILE *fp;
        char fname[30];
        FILE *zadanierec;
        char* file_name = "rec_vvod.txt";
        printf("\n\n  Введите имя файла: "); //ввод имени файла 
        scanf("%s", &fname);
        if ((fp = fopen(fname, "r")) == NULL)       //если введенного файла не существует
        {
            printf("\nТакого файла нет");
            printf("\nДанные заносятся автоматически из файла rec_vvod.txt");
            zadanierec = fopen( file_name, "r" );
            fscanf(zadanierec, "%d\n", &N);
        }
        else                    //если файл существут
        {
            fscanf(fp, "%d\n", &N);
        }
        _getch();
    }   
    return N;           //возвращение значения N
}
 
/* ФУНКЦИЯ ДЛЯ ВВОДА N МАССИВА ( с клавиатуры ) */
 
int input_matr(int N ,char typeInput , char typeTask)
{
    int const maxNat=10;        //ограничение на размерность матрицы
        system("cls");
        do
        {
            printf("\t Введите размерность массива ( 1 ... %d ) : ",maxNat);
            N=zashita_matr();           //защита на ввод размерности массива
            if (N>maxNat)
            {
                printf(" Вы ввели неправильное число.");
                printf("\n Нажмите любую клавишу.\n");
                _getch();
            }
        }
        while (N>maxNat);           //повторять ввод до тех пор пока число
                            //не будет входить в определённый промежуток
    return N;
}
/* ФУНКЦИЯ ДЛЯ ВВОДА ЭЛЕМЕНТОВ МАССИВА ( с клавиатуры ) */
 
double input_matr2(int N ,double **A, double **B)
{
    int i,j;
    printf(" Заполните массив A:\n");
 
    for ( i=0; i<N; i++)
        for ( j=0; j<(N-i); j++)
        {
            printf ("A[%d][%d] = ",i,j);
            A[i][j]=zashita_elem();
        }
        printf(" Заполните массив B:\n");
 
    for ( i=0; i<N; i++)
        for ( j=0; j<(N-i); j++)
        {
            printf ("B[%d][%d] = ",i,j);
            B[i][j]=zashita_elem();
        }
        return **A,**B;
}
/* ФУНКЦИЯ ДЛЯ ВЫВОДА ДАННЫХ РЕКУРСИИ*/
 
void output_rec(int N,char typeInput, char typeTask, char typeOutput,double itog)
{
if(typeOutput == '1')       //на экран
    {
        printf("\n\tПри N = %d результат равен : %.15lf",N,itog);    //вывод окончательного результата
        printf("\nНажмите любую клавишу для продолжения...\n");
        _getch();
    }
    else                    //в файл
    {
        FILE *rezultati_rec;
        FILE *fp;
        char fname[30];
        char* file_name = "rec_vyvod.txt";  
        rezultati_rec = fopen( file_name, "w" );    //данные сохраняются в файл "rec_vyvod.txt"
 
        printf("\n\n  Введите имя файла: "); //ввод имени файла 
        scanf("%s", &fname);
 
        if ((fp = fopen(fname, "r")) == NULL)       //если введенного файла не существует
        {
            printf("\nВведенный файл отсутствует");
            printf("\nДанные автоматически заносятся в файл rec_vyvod.txt");
            fprintf(rezultati_rec,"\nПри %d",N);
            fprintf(rezultati_rec,"\n\n  результат рекурсии : %.15lf\n\n", itog);
            fclose(rezultati_rec);
            printf("\n\tДанные сохранены");
        }
        else                //если файл существут
        {
            fprintf(rezultati_rec,"\nПри размерности массива %d",N);
            fprintf(rezultati_rec,"\n\n  результат рекурсии : %.15lf\n\n", itog);  
            fclose(rezultati_rec);
 
 
            printf("\n\tДанные сохранены");
        }
        _getch();
    }
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!
/* ФУНКЦИЯ ДЛЯ ВЫВОДА ДАННЫХ МАТРИЦЫ*/
void output_matr(int N,char typeInput, char typeTask, char typeOutput, double **A1, double **B1, double **D)
{
    int i, j;
    if(typeOutput == '1')       //на экран
    {
        
        printf("Введен массив A, размерности %d",N);
            printf("\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            printf("%g ",A1[i][j]);
            
            
        }
        printf("\n");
        }
 
        printf("Введен массив B, размерности %d",N);
        printf("\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            printf("%g ",B1[i][j]);
        }
        printf("\n");
        }
 
            printf("  Решение:");
            printf("Массив А*В\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            printf("%g ",D[i][j]);
        }
        printf("\n");
        }
        printf("\nНажмите любую клавишу для продолжения...");
        _getch();
    }
 
    else            //в файл
    {
        FILE *fp;
        FILE *rezultati_matrici;
        char fname[30];
        char* file_name = "matr_vyvod.txt";
        rezultati_matrici = fopen( file_name, "w" );        //результат сохраняется в файл "matr_vyvod.txt"
        printf("\n\n  Введите имя файла: "); //ввод имени файла 
        scanf("%s", &fname);
 
        if ((fp = fopen(fname, "r")) == NULL)       //если введенного файла не существует
        {
            printf("\nВведенный файл отсутствует");
            printf("\nДанные автоматически заносятся в файл matr_vyvod.txt");
            fprintf(rezultati_matrici,"Введен массив A, размерности %d",N);
            fprintf(rezultati_matrici,"\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            fprintf(rezultati_matrici,"%g ",A1[i][j]);
            
            
        }
        fprintf(rezultati_matrici,"\n");
        }
 
        fprintf(rezultati_matrici,"Введен массив B, размерности %d",N);
        fprintf(rezultati_matrici,"\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            fprintf(rezultati_matrici,"%g ",B1[i][j]);
        }
        fprintf(rezultati_matrici,"\n");
        }
 
            fprintf(rezultati_matrici,"  Решение:");
            fprintf(rezultati_matrici,"Массив А*В\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            fprintf(rezultati_matrici,"%g ",D[i][j]);
        }
        fprintf(rezultati_matrici,"\n");
        }
        fclose(rezultati_matrici);
            printf("\n\tДанные сохранены");
        }
 
        else        //если файл существут
        {
 
 
            fprintf(rezultati_matrici,"Введен массив A, размерности %d",N);
            fprintf(rezultati_matrici,"\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            fprintf(rezultati_matrici,"%g ",A1[i][j]);
            
            
        }
        fprintf(rezultati_matrici,"\n");
        }
 
        fprintf(rezultati_matrici,"Введен массив B, размерности %d",N);
        fprintf(rezultati_matrici,"\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
            
            fprintf(rezultati_matrici,"%g ",B1[i][j]);
        }
        fprintf(rezultati_matrici,"\n");}
 
            fprintf(rezultati_matrici,"  Решение:");
            fprintf(rezultati_matrici,"Массив А*В\n");
        for (i=0;i<N;i++)
        {
        for (j=0;j<(N-i);j++)
        {
        fprintf(rezultati_matrici,"%g ",D[i][j]);
        }
        fprintf(rezultati_matrici,"\n");}
            fclose(rezultati_matrici);
            printf("\n\tДанные сохранены");
        }
        _getch();
    }   
}
double recursia(int N)
{
static int l=0;                                                 //к-элемент
        static double x=1;                                  //значение при cos и sin
        static double a,b,c,d;                              
        static double a0,a1,a2,a3,a4;                       //значение элемета
        static double itog=0;                               //результат
        
        
                
if(l==N)
{
    l=0,a=0,a0=0,a1=0,a2=0,a3=0,a4=0;
    b=0,c=0,d=0;
}
 
    else
    {   
        if(l==0)
        {   itog=0;
            a0=(cos (x) * cos (x));
            a=a0;
            itog=a0*a0;
            ++l;
                
        }
            else{
            if(l==1)
            {
            a1=-(sin (x) * sin (x));
            b=a1;
            itog+=b*b;
            ++l;
        
            }
                else{
                if(l==2)
                {   
                 a2=2*b-a;
                itog=itog+(a2*a2);
                c=a2;           
                ++l;
 
            }
                else{
                if(l==3)
                {   
                a3=2*c-b;
                itog=itog+(a3*a3);
                d=a3;           
                ++l;
 
                    }
                    else
                    {   
                       a4=2*d-c;
                        itog=itog+(a4*a4);
                        c=d;
                        d=a4;
                        ++l;
                }
                }
                }
            }
        recursia(N);
        
        
}
    return itog;
}
/* МАТРИЦА */
 
double matrix(int N, double **A, double **B, double **A1, double **B1,double **D)
{
    int i,j;
    int z;
    
    
for (i=0;i<N;i++)
{
    for (j=0;j<(N);j++)
    {
        A1[i][j]=0;
        B1[i][j]=0;
    }
}
 
                for (i=0;i<N;i++)
                {
                for (j=0;j<(N);j++)
                {
                if ((i+j+1)<=N)                 
                    A1[i][j]=A[i][j];           
                }
                }
 
 
                    for (i=0;i<N;i++)
                    {
                        for (j=0;j<(N);j++)
                    {
                        if ((i+j+1)<=N) 
                        {
                            B1[i][j]=B[i][j];
                        }
                    
                    }
                    }
 
for (i=0;i<N;i++)
for (j=0;j<(N-i);j++)
{
    for(D[i][j]=0,z=0;z<N;z++)
    D[i][j]+=A1[i][z]*B1[z][j];
}
return **A1,**B1,**D;
}
/* ЗАЩИТА */
 
/* Функция защиты при вводе N в рекурсии */
int zashita_rec()
{
    int k=0,in=0;
    char ch=0,mas[200];             //ограничение на ввол - 200 символов
    do
    {
        ch=_getch();
        if(ch>=48 && ch<=58 && k<2)         //разрешён ввод чисел от 0 до 9, количество чисел - 2
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
        }
        in=atoi(mas);
    }
    while(ch!=13 ||in==0);
    printf("\n");
    return in;
}
 
/* Функция защиты при вводе N в матрице */
int zashita_matr()
{
 
 
    int k=0,in=0;
    char ch=0,mas[200];             //ограничение на ввол - 200 символов
    do
    {
        ch=_getch();
        if(ch>=48 && ch<=58 && k<2) //разрешён ввод чисел от 0 до 9, количество чисел - 2
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
        }
        in=atoi(mas);
    }
    while(ch!=13 ||in==0);
    printf("\n");
    return in;
}
 
/* Функция защиты при вводе элементов в матрице */
int zashita_elem()
{
    int k=0,in=0;
    char ch=0,mas[200];                 //ограничение на ввол - 200 символов
    do
    {
        ch=_getch();
        if(ch>=48 && ch<=58 && k<3)        //разрешён ввод чисел от 0 до 9, количество чисел - 3
        {
            printf("%c",ch);
            mas[k]=ch;
            k++;
        }
        if (ch==8&&k!=0)
        {
            printf("%c %c",8,8);
            mas[k]=0;
            k--;
        }
        in=atoi(mas);
    }
    while(ch!=13 ||in==0);
    printf("\n");
    return in;
}