Удачно откомпилировать исходлник

@madbounce · Регистрация: 20.04.2012

Author24 — интернет-сервис помощи студентам

Ребят, всем привет. Хотел обратиться к Вам с такой просьбой. Мало знаком с "сишкой", так вот нарыл исходники по нужной мне теме, я так понял на с++ . Так вот чет промаялся день, хотел откомпилить на старом компляторе Turbo C++, ловлю много ошибок. Некоторые вообще не понимаю. В общем "не удалось", как говориться. А вот саму работу программы очень нужно глянуть. Если кто сможет, попробуйте запустить.
Во вложениях всего шесть исходников 07_01, 07_02 и т.д. В текстовом формате. А также я так понял самописная библиотека megastat (тоже в TXT), которая используется в тексте в "инклуд". Ну собственно с этой библиотекой проблемы, сохранил её как MEGASTAT.H, кинул в INCLUDE, но компилятор выдал много ошибок. С чего бы вдруг ? Вообще исходники из книги, т.е. из приложения к книге. Пробоавал только этим компилятором. Может даже кто-то сможет закинуть текст путем создания нового консольного приложения в Visual Studio например. Пожалуйста, помогите (

megastat.txt

C++

//Исходные коды
// File megastat.h
 
/////////////////////////////////
// Used for non—Borland compilers
#define M_LOG2E  1.44269504088896340736  // 1 / log (2)
#define M_LOG10E 0.434294481903251827651 // 1 / log (10)
#define M_PI    3.14159265358979323846  // Число "пи"
#define M_SQRT2  41421356237309504880  // Корень квадратный из 2
#define M_LN2     0.693147180559945309417
 
#define SQRT_2       1.4142135
#define SQRT_M_PI    1.7724538                // Корень квадратный из "пи"
#define SQRT_M_PI_2  2.5066282                // Корень квадратный из "2 * пи"
 
////////////////////////////////////////////////////////
// User defined function for Newton—Cotes family methods
typedef double (*userFunc) (double);
 
//////////////////////////////////////////////////
// User defined functions for optimization methods
typedef double (*userFuncRight) (double*,int);
typedef void (*userFuncGrad)(double*,double*,int,double,
userFuncRight);
typedef void (*userFuncHesse)(double*,double*,int,double,
userFuncRight);
 
////////////////////////////////////////////////////////
// User defined function for experimental design methods
typedef void (*userFuncMany) (double,double*,int,double*);
 
/////////////
// Prototypes
double Abbe (double*,int);
double AbbeDistribution (int, double);
double AbsMaximumOf (double*,int);
double ApproximationWilks (double,int,int,int);
double Arcctg (double);
double Arth (double);
double Bayes (double*,int,int,int,int*,int*,double*);
double Beta (double,double);
double BetaDistribution (double,double,double);
double BetaS (double,double);
double Bravais (double*,double*,int);
double CanonicalCorrelation (double,double);
double ChiSquare (double*,double*,int);
double ChiSquareDistribution (double,double);
double ChiSquareEmpire (double*,double*,int,double);
double ChiSquareIntegral (double,double);
double CityBlock (double*,double*,int);
double CochraneGDistributionApprox (double,double,double);
double CochraneGDistributionExact (double,double,double);
double Combination (int,int);
double Concord (double*,int,int);
double Confidence interval (int,double,double,int);
double Cov (double*,double*,int);
double CriticalW (int,double);
double DannDistribution95 (int);
double DannDistribution95c (int);
double DannDistribution99 (int);
double DannDistribution99c (int);
double Det (double*,int);
double DuncanDistribution (double,int,int);
double Entropie (double*,int);
double Euclid (double*,double*,int);
double EuclidNorma (double*,int);
double EuclidNormaTri (double*,int);
double EuclidNormaVector (double*,int);
double EuclidNormaWithoutDiag (double*,int);
double Factorial (int);
double FDistribution (double,double,double);
double Fechner (double*,double*,int);
double FeedforwardError (double*,int);
double FisherIrwin (int,int,int,int);
double Gamma (double);
double GammaE (double);
double GammaI (double);
double GammaS (double);
double Geary (double*,int);
double GearyDistribution (int, double);
double GTest (double*,double*,int);
double GTestDistribution (int,double);
double Hemming (double*,double*,int);
double Horner (double*,int,double);
double InfiniteNorma (double*,int);
double InverseAbbeDistribution (int, double);
double InverseBetaDistribution (double,double,double);
double InverseBetaDistributionBig (double,double,double);
double InverseChiSquareDistribution (double,double);
double InverseChiSquareDistributionBig (double,double);
double InverseFDistribution (double,double,double);
double InverseGearyDistribution (int, double);
double InverseGTestDistribution (int,double);
double InverseNormalDistribution (double);
double InversePagurovaDistribution (int,int,double,double);
double InverseSerialDistribution (int,int,int);
double InverseTDistribution (double,double);
double InverseXDistribution (double,double,double);
double Jaccard (double*,double*,int);
double KolmogorovDistribution (double);
double KolmogorovOneSided (double*,int);
double KolmogorovTwoSided (double*,int);
double Krauth (double*,double*,double*,int);
double Krauth (double*,int);
double Kullback (double*,double*,int);
double Lagrange (double,double*,double*,int);
double LambdaDistribution (double);
double LogFactorial (int);
double Mahalanobis (double*,double*,double*,int);
double MannWhitneyDistribution (int,int,double);
double MaxEntropie (int);
double MaximumOf (double*,int);
double MaximumOf (double*,int,int*);
double MaximumOf (double,double);
double MinimumOf (double*,int);
double MinimumOf (double*,int,int*);
double MinimumOf (double,double);
double Minkovski (double*,double*,int,int);
double Mode (double*,double*,int);
double Moment (int,double*,int,double*,int);
double NormalDistribution (double);
double OmegaSquare (double*,double*,int);
double OmegaSquareDistribution (double);
double Organization (double*,int);
double Pearson (double*,double*,int);
double PowerOf (double,int);
double Quality (int*,int,int*,int*);
double Rank (double*,double*,int);
double Range (double*,int);
double RangeNormal(double,int);
double RangeNormalDensity (double,double,int);
double RangeNormalIntegral (double,int);
double RangeStudent(double,int,int);
double RangeStudentDensity (double,double,int,int);
double RankKendall (double*,double*,int);
double Rao (double*,double*,int);
double RelEntropie (double,double);
double ShapiroWilk (double*,int);
double Sign (double);
double SignNull (double);
double SignTest (double*,double*,int);
double Simpson (double,double,int,userFunc);
double SmartRound (double x);
double Smirnov (double*,double*,int);
double SmirnovExact (double*,double*,int,int);
double Sokal (double*,double*,int);
double Stirling (int);
double StudentPairedTest (double*,double*,int);
double Sup (double*,double*,int);
double Surplus (double,double);
double TDistribution (double,double);
double Trace (double*,int);
double Trapezium (double,double,int,userFunc);
double UDistribution (int,int,double);
double VectorSum (double*,int);
double VectorSumSQ (double*,int);
double WilcoxonTDistribution (int,double);
double Wilks (double*,int,int,double);
double WTDistribution (int,double);
double Yule (double*,double*,int);
int AnsariBradleyTest (double*,double*,int,int,double*);
int Bartlett (double*,int*,int,double*);
int Biserial (double*,double*,int,double*);
int Biserial (double*,int,double*);
int BrandtSnedecor (double*,int,int,double*);
int        Canonical Correlation Analysis (double*,double*,
int,int,int,double*,double*,double*,double*,double*);
int Canonical Discriminant Analysis (double*,int,int,double*,
double*,double*,int*,int,int*,double*,double*);
int CDAClass (double*,int,int,int,double*,int,double*,int*);
int Choleski (double*,double*,int);
int Chuprov (double*,int,int,double*,double*);
int CochraneG (double*,int,int,double*);
int CochraneQ (double*,int,int,double*);
int Combination (double*,int,int,double,double*);
int ConditionNumber (double*,int,double*);
int ConjugateGradient (double*,int,double,int*,double,
userFuncGrad,userFuncRight);
int Dann (double*,int*,int,double*);
int BFGS (double*,int,double,int*,double,userFuncGrad,
userFuncRight);
int Derive (double,double*,int,double*,double*,userFuncMany);
int Eigen (double*,double*,int,double,int*);
int ExponentFunction (double*,double*,int,double*,double*);
int ExponentialFunction (double*,double*,int,double*);
int ExpPowerFunction (double*,double*,int,double*,double*);
int FDAClass (double*,int,int,int,double*,double*,int*);
int FisherDiscriminantAnalysis (double*,int,int,int*,int,int*,double*,double*);
int FrancisKublanovskaya (double*,int,double,int*);
int Friedman (double*,int,int,double*);
int FTest (double*,double*,int,int,double*);
int Gauss (double*,double*,int,int,double);
int GompertzFunction (double*,double*,int,double*,double*);
int Gower (double*,int,int,int*,double*);
int Gram (double*,int);
int GramSchmidt (double*,double*,int,int);
int Hotelling (double*,double*,int,int,int,double*);
int Householder (double*,int,double*,double*);
int HyperFunction (double*,double*,int,double*,double*);
int InverseMatrix (double*,double*,int);
int InversePolynomial (double*,double*,int,int,int,double*);
int Jacobi (double*,int,double,int*,double*);
int JonckheereTerpstra (double*,int*,int,double*,double*);
int KellyWood (double*,double*,int,double*);
int Kendall (double*,double*,int,double*);
int King (double*,int,int,int,int*,int*,double*);
int KruskalWallis (double*,int*,int,double*);
int LDAClass (double*,int,int,int,double*,double*,double*,
double*,int*);
int Likeness (double*,double*,double*,int,int,int);
int LikenessForCorrelation (double*,double*,int,int,int);
int LinearDiscriminantAnalysis (double*,int,int,int*,int,int*,
double*,double*,double*);
int LinearRegression (double*,double*,double*,int,int);
int LinearRegression0 (double*,double*,double*,int,int);
int LogarithmFunction (double*,double*,int,double*,double*,
double*);
int LogisticFunction (double*,double*,int,double*,double*,
double*);
int MannWhitneyTest (double*,double*,int,int,double*,double*);
int MaximumLikelihood (double*,int,double*,double*,int,int*);
int MaximumOf (int*,int);
int MaximumOf (int,int);
int MaximumPath (double*,int,int*,int*,double*);
int McQueen (double*,int,int,int,int,int*,double*,double*,int*);
int Median (double*,int,double*,double*);
int Median (double*,int,double*,int,double*,double*);
int MedianDistribution (int,int,double);
int MinimumOf (int*,int);
int MinimumOf (int,int);
int MultyFactor (double*,int,int,double*,double*);
int Near (double*,int,int,int,int*,int*,double*);
int NearLink (double*,int,int*,int*,double*);
int NelderMead (double*,int,double,int*,double,double,double,
double,userFuncRight);
int Newton (double*,double*,int,int*,double);
int Newton (double*,int,double,int*,double,userFuncHesse,
userFuncGrad,userFuncRight);
int NumberOfMinus (double*,int);
int OneWayAnalysis (double*,int*,int,double*);
int OrtoPlan (double*,int,int,int);
int Page (double*,int,int,double*,double*);
int Pagurova (double*,double*,int,int,double*,double*);
int Parity (int);
int PlusDef (double*,int);
int Point (double*,double*,int,double*);
int PolynomCoeff (double*,int,double*);
int Polynomial (double*,double*,int,int,int,double*);
int PowerFunction (double*,double*,int,double*,double*);
int PrincipalFactor (double*,int,double*,int*);
int PseudoInverseMatrix (double*,double*,int,int);
int QDistribution (int,int,double,int*);
int QRDecomposition (double*,double*,double*,int,int);
int RandomCriterion (double*,double*,int,double*);
int RandomCriterionIndependent (double*,double*,int,int,double*);
int RangeOfVar (double,double,double,double*);
int RangeOfVarDistribution (double,double,double*,double*);
int Reduction (double*,double*,int,int);
int Rings (double*,int,int*,int*,int*);
int Rosenbaum (double*,int,double*,int);
int Sarkadi (double*,int,int,double*,double*);
int Scheffe (double*,int*,int,double*);
int ScheffePair (double*,int,int,double*,double*);
int Sign (int);
int SignDistribution (int,double);
int SimpleIteration (double*,double*,double*,int,double,int*);
int SingularValueDecomposition (double*,int,int,double*,
double*,double*);
int Solves (double*,double*,int,int);
int Spearman (double*,double*,int,double*);
int SpecialVectorSum (int*,int);
int Student (double*,double*,int,int,double*,int*);
int Sturgesss (int);
int Thurstone (double*,int,double*,int);
int Torgerson (double*,int,double*,double*,int*);
int Tou (double*,int,int,int,double*);
int TwoDegree (int);
int VanDerWaerdenTest (double*,double*,int,int,double*);
int Varimax (double*,int,int);
int VectorSum (int*,int);
int WaldWolfowitz (double*,int,double*,int,double*);
int Ward (double*,int,int,int*,int*,double*);
int Welch (double*,double*,int,int,double*,int*);
int WilcoxonSignedTest (double*,double*,int,double*,double*);
int WilcoxonTest (double*,double*,int,int,double*,double*);
void Allocate (double*,int,double*,double*,int);
void AllocateCommon (double*,double*,double*,double*,
double*,int,int,int);
void ArrayToArray (double*,double*,int);
void CoeffOfVariance (double*,int,double*,double*);
void ColInterchange (double*,int,int,int);
void ColMultiplyNumber (double*,int,int,double);
void CombinationAdd (double*,int,int,double*,double,int*,
double*,int);
void Compare (double*,double*,int,int,int*,int*);
void Confidence interval (double,int,double,double*,double*);
void Confidence interval (int,double,double,int,double*,
double*);
void Confidence interval (int,double,double,int,double*,double*);
void Feedforward (double*,double*,double*);
void FillUp (double*,int,double);
void FillUp (int*,int,int);
void FillUpCol (double*,int,int,double);
void FillUpDiag (double*,int,double);
void FillUpRow (double*,int,int,int,double);
void Fourier (double*,int,int,double*,double*);
void FrequencyNormal (double*,double*,int,double,double);
void FullOrtoPlan (signed char*,int);
void Gerschgorin (double*,int,double*,double*);
void GetMinMax (double* xmin,double* xmax);
void Gini (double*,int,double*);
void Givens (double*,int,double*,int);
void GradC (double*,double*,int,double,userFuncRight);
void GradL (double*,double*,int,double,userFuncRight);
void GradR (double*,double*,int,double,userFuncRight);
void HesseC (double*,double*,int,double,userFuncRight);
void Hessenberg (double*,int);
void HesseR (double*,double*,int,double,userFuncRight);
void Kurtosis (double*,int,double*,double*);
void MatrixDivideNumber (double*,int,double);
void MatrixMinusDiag (double*,double*,int);
void MatrixMinusMatrix (double*,double*,double*,int);
void MatrixMinusMatrix (double*,double*,int);
void MatrixMultiplyMatrix  (double*,double*,double*,int,int,int);
void MatrixMultiplyMatrixT (double*,double*,double*,int,int,int);
void MatrixMultiplyNumber (double*,int,double);
void MatrixMultiplyVector (double*,double*,double*,int);
void MatrixPlusDiag (double*,double*,int);
void MatrixPlusMatrix (double*,double*,double*,int);
void MatrixPlusMatrix (double*,double*,int);
void MatrixT (double*,double*,int,int);
void MatrixTMultiplyMatrix (double*,double*,double*,int,int,int);
void MatrixUnit (double*,int);
void NormalizeMatrix (double*,int,int,double*);
void NumberInterchange (int*,int*);
void OptimalPlan (int,int*,int*);
void PercentOfVariance (double*,int,double*,double*,int);
void PolynomCoeffMinor (double*,int,double*);
void RankCommon (double*,double*,double*,double*,int,int);
void Reverse (double*,int);
void RowInterchange (double*,int,int,int,int);
void RowMultiplyNumber (double*,int,int,int,double);
void SampleMean (double*,int,double*,double*);
void ScalarMatrix (double*,double*,int);
void SerialDistribution (int,int,double,int*,int*);
void Sharp (double*,int,double*,double*);
void Skewness (double*,int,double*,double*);
void SortArrayCommon (double*,double*,int);
void SortArrayDown (double*,int,int*,int);
void SortArrayDown (int*,int,int*,int);
void SortArrayUp (double*,int,int*,int);
void SortArrayUp (int*,int,int*,int);
void UnSortArray (double*,double*,int,int*);
void Variance (double*,int,double*,double*);

07_06.txt

C++

Исходные коды
void PercentOfVariance (double z[],int k,double r[],double s[],int ms)
//
// Функция вычисляет процент дисперсии, выделенной факторами.
// Обозначения:
//   z — корреляционная матрица,
//   k — размерность корреляционной матрицы,
//   r — матрица факторного отображения,
//   s — вектор процентов дисперсии,
//  ms — число факторов.
// Примечание:
//  функция применяется после успешного завершения факторного
//  анализа, поэтому ошибка типа нулевой суммарной дисперсии
//  не отслеживается.
// Возвращаемое значение:
//  нет.
//
{
 register int i,j; // Счетчики
 
 int m;            // Счетчик одномерного массива
 
 double sd = 0;    // Суммарная дисперсия
 
 for (i = 0, m = 0; i < k; i++)
   {
    sd += z[m];
    m += k + 1;
   }
 
 for (i = 0, m = 0; i < ms; i++)
   {
    for (j = 0, s[i] = 0; j < k; j++, m++)
      s[i] += r[m] * r[m];
 
    s[i] /= sd / 100;
   }
}

07_05.txt

C++

Исходные коды
int Varimax (double r[],int k,int m)
//
// Функция производит варимакс—вращение матрицы факторного
// отображения.
// Обозначения:
//   r — матрица факторного отображения размером k * m,
//   k — размерность корреляционной матрицы, k > 2,
//   m — число факторов.
// Возвращаемое значение:
//   0 при нормальном окончании счета,
//  —1 при недостатке памяти для рабочих массивов.
//
{
 register int i,j,j1; // Счетчики цикла
 
 int m1,m2,m3,m4;     // Счетчик одномерного массива
 
 double *x,           // Вращаемая пара векторов
        *y,           // Повернутая пара векторов
        *h,           // Суммарная нагрузка
        u,v,          // Вспомогательные переменные
        A,B,C,D,
      vc = 0,vc1,   // Величина для проверки окончания процедуры
        num,          // Числитель и знаменатель
        cs[4];        // Матрица вращения
 
 if ((h = new double[k]) == 0)
   return —1;
 
 //////////////////////////////////
 // Нормализация факторных нагрузок
 for (i = 0; i < k; i++)
   {
    for (j = 0, h[i] = 0, m1 = i; j < m; j++, m1 += k)
      h[i] += r[m1] * r[m1];
    h[i] = sqrt (h[i]);
   }
 
 for (i = 0,m1 = 0; i < m; i++)
   for (j = 0; j < k; j++)
     r[m1++] /= h[j];
 
 if ((x = new double[k * 2]) == 0)
   {
    delete [] h;
    return —1;
   }
 if ((y = new double[k * 2]) == 0)
   {
    delete [] x;
    return —1;
   }
 
 do
   {
    vc1 = vc;
 
    ////////////////
    // Цикл вращения
    for (i = 0; i < m — 1; i++)
      {
       for (j = i + 1,m3 = j * k,m4 = m3; j < m; j++)
         {
          ///////////
          // Вектор x
          for (j1 = 0,m1 = i * k,m2 = m1; j1 < k; j1++)
            x[j1] = r[m1++];
 
          ///////////
          // Вектор y
          for (j1 = k; j1 < k + k; j1++)
            x[j1] = r[m3++];
 
          /////////////////////////////////////
          // Вычисление вспомогательных величин
          for (j1 = 0,A = 0,B = 0,C = 0,D = 0; j1 < k; j1++)
            {
             u = x[j1] * x[j1] — x[j1 + k] * x[j1 + k];
v = 2 * x[j1] * x[j1 + k];
             A += u;
             B += v;
             C += u * u — v * v;
             D += u * v;
            }
 
          //////////////////////////////////////
          // Тангенс учетверенного угла вращения
          num = 2 * (D — A * B / k);
          u = num / (C — (A * A — B * B) / k);
 
          ///////////////////////////////////////////
          // Выбор угла из условия максимума критерия
          if (u > 0 && num < 0)
            u = atan (u) — M_PI;
          else if (u < 0 && num > 0)
            u = atan (u) + M_PI;
          else
            u = atan (u);
 
          u /= 4;
 
          ////////////////////////////
          // Если вращение имеет смысл
          if (fabs (u) >= 0.000001)
            {
             //////////////////////////////
             // Вычисление матрицы вращения
             cs[0] = cos (u);
             cs[1] = sin (u);
             cs[2] = —cs[1];
             cs[3] = cs[0];
 
             /////////////////////////
             // Вращение пары векторов
             MatrixMultiplyMatrix (x,cs,y,k,2,2);
 
             //////////////////////
             // Вектор x — на место
             for (j1 = 0; j1 < k; j1++)
               r[m2++] = y[j1];
 
             //////////////////////
             // Вектор y — на место
             for (j1 = k; j1 < k + k; j1++)
               r[m4++] = y[j1];
            }
         }
      }
 
    ///////////////////////////////////////////
    // Проверка сходимости по варимакс—критерию
    for (i = 0,vc = 0,m1 = 0; i < m; i++)
      {
       for (j = 0,u = 0,v = 0; j < k; j++,m1++)
         {
          A = r[m1] * r[m1];
          u += A * A;
          v += A;
         }
       vc += k * u — v * v;
      }
 
   } while (fabs (vc1 — vc) > 0.000001);
 
delete [] x; delete [] y;
 
 ////////////////////////////////////
 // Денормализация факторных нагрузок
 for (i = 0,m1 = 0; i < m; i++)
   for (j = 0; j < k; j++)
     r[m1++] *= h[j];
 
 delete [] h;
 
 return 0;
}

07_04.txt

C++

Исходные коды и пример применения
#include <fstream.h>
#include <iomanip.h>
#include <math.h>
 
#include "megastat.h"
 
void main (void)
{
 register int i,j; // Счетчики цикла
 
 int n = 6,        // Размерность корреляционной матрицы
     p = 3,        // Число выделяемых факторов
     m,            // Счетчик одномерного массива
     Code;         // Код ошибки
 
 double a[] =      // Исходная корреляционная матрица
              {1.000,0.299,0.400,0.297,0.116,0.232,
               0.299,1.000,0.568,0.534,0.432,0.154,
               0.400,0.568,1.000,0.487,0.436,0.071,
               0.297,0.534,0.487,1.000,0.545,0.092,
               0.116,0.432,0.436,0.545,1.000,0.016,
               0.232,0.154,0.071,0.092,0.016,1.000},
        *c,        // Матрица факторного отбражения
        s;         // Рабочая переменная
 
 c = new double[n * p];
 
cout << "Original correlation matrix\n";
 for (i = 0, m = 0; i < n; i++)
   {
    for (j = 0; j < n; j++, m++)
      cout << setw (10) << a[m];
    cout << endl;
   }
 
 Code =  Thurstone (a,n,c,p);
 cout << "Return code is " << Code << endl;
 
 if (!Code)
   {
    cout << "Factor loading matrix\n";
    for (i = 0, m = 0; i < p; i++)
      {
       for (j = 0; j < n; j++, m++)
         cout << setw (10) << c[m];
       cout << endl;
      }
    cout << "Variances\n";
    for (i = 0, m = 0; i < n; i++)
      {
       for (j = 0, m = i, s = 0; j < p; j++, m += n)
          s += c[m] * c[m];
       cout << setw (10) << s;
      }
    cout << endl;
   }
 
 delete [] c;
}
 
int Thurstone (double a[],int n,double c[],int p)
//
// Функция выполняет факторный анализ центроидным методом.
// Обозначения:
//  a — корреляционная матрица,
//  n — порядок корреляционной матрицы,
//  c — матрица факторного отображения размером не менее n x p,
//  p — заданное число факторов.
// Возвращаемое значение:
//   0 при нормальном окончании расчета,
//  —1 при недостатке памяти для вычислений.
//
{
 register int i,j,k; // Счетчики цикла
 
 int m,              // Рабочий индекс
     mg = 0,         // Счетчик матрицы факторного отбражения
     *sign,          // Массив информации о перемене знаков
     l,              // Счетчик отрицательных знаков столбца
     Code = 0;       // Возвращаемое значение
 
 double *r,          // Редуцированнная корреляционная матрица
        *r1,         // Матрица остаточных корреляций
        *b,          // Массив сумм элементов столбцов
        s;           // Итоговая сумма
 
 if ((r = new double[n * n]) == 0)
   return —1;
 if ((r1 = new double[n * n]) == 0)
   {
    delete [] r;
    return —1;
   }
 if ((b = new double[n]) == 0)
   {
    delete [] r; delete [] r1;
    return —1;
   }
 if ((sign = new int[n]) == 0)
   {
    delete [] r; delete [] r1; delete [] b;
    return —1;
   }
 
 ////////////////////////////////////
 // Начальные значения массива знаков
 FillUp (sign,n,1);
 
 ////////////////////////////////////////
 // Копия исходной корреляционной матрицы
 ArrayToArray (a,r1,n * n);
 
 //////////////////////////
 // Цикл выделения факторов
 for (k = 0; k < p; k++)
   {
    /////////////////////////////////////////
    // Редукция матрицы остаточных корреляций
    if (Reduction (r1,r,n,1) != 0)
      {
       Code = —1;
       break;
      }
 
    ////////////////////////////////////
    // Суммы столбцов матрицы корреляций
    for (i = 0, m = 0; i < n; i++)
      for (j = 0, b[i] = 0; j < n; j++)
        b[i] += r[m++];
 
    s = sqrt (VectorSum (b,n));
    for (i = 0; i < n; i++)
      {
       ///////////////////////////////
       // Нагрузки на текущий центроид
       b[i] /= s * sign[i];
 
       ///////////////////////////////////////////////
       // Заполнение матрицы факторного отображения
       c[mg++] = b[i];
      }
 
    ////////////////////////////////
    // Матрица остаточных корреляций
    for (i = 0, m = 0; i < n; i++)
      for (j = 0; j < n; j++)
        r[m++] —= b[i] * b[j];
 
    //////////////////////////////////////////////
    // Анализ знаков матрицы остаточных корреляций
    FillUp (sign,n,0);
    for (i = 0; i < n; i++)
      for (j = i, m = i * n + i; j < n; j++)
        if (Sign (r[m++]) == —1)
          sign[j]++;
    for (i = 0; i < n; i++)
      sign[i] = sign[i] >= n / 2 ? —1 : 1;
 
    /////////////////////////////////////
    // Перемена знаков матрицы остаточных корреляций
    for (i = 0, m = 0; i < n; i++)
      for (j = 0; j < n; j++, m++)
        r1[m] = (sign[i] == —1 && sign[j] != —1) ||
                (sign[j] == —1 && sign[i] != —1) ? —r[m] : r[m];
   }
 
 delete [] r; delete [] r1; delete [] b; delete [] sign;
 
 return Code;
}

07_06.txt

C++

Исходные коды и пример применения
#include <fstream.h>
#include <iomanip.h>
#include <math.h>
 
#include "megastat.h"
 
void main (void)
{
 register int i,j,i1; // Счетчики
 
 int Code,            // Код ошибки
     n = 17,          // Число объектов
     k = 12,          // Число параметров
     m,               // Вычисленное количество факторов
     Factor = 4;      // Заданное пользователем число факторов
 
 double z[] = {       // Исходные данные
9.1,9.2,6.6,6.5,8.6,4.7,7.9,4.9,4.0,5.1,4.0,5.3,6.0,8.5,4.2,8.0,10.9,
33,29,29,27,27,17,23,27,32,21,27,24,20,30,21,26,24,
0.44,1.54,0.82,0.63,0.78,0.15,0.42,0.43,0.7,0.51,0.3,0.43,0.41,1,0.5,1.1,1.2,
23,58,43,36,34,19,23,26,54,51,24,34,34,40,57,50,45,
0.48,0.96,0.59,0.51,0.62,0.5,0.4,0.63,0.58,0.43,0.4,0.47,0.37,0.9,0.37,0.85,1.1,
25,36,31,29,27,63,21,38,46,40,38,37,31,34,42,41,41,
0.03,0.08,0.06,0.05,0.07,0.024,0.05,0.05,0.02,0.03,0.02,0.04,0.04,0.1,0.053,0.1,0.05,
2,3,3,3,3,3,3,3,2,3,2,3,3,4,6,5,2,
1.55,1.2,3.4,3.8,1.6,7.0,1.4,1.0,1.05,2.3,3.5,6.0,1.1,0.98,1.6,2.3,5.9,
0.78,0.62,1.08,1.92,0.61,1.6,1.0,1.44,1.44,4.8,2.0,4.4,1.28,0.96,0.68,0.72,1.04,
9.2,7.4,12,12.6,6.72,16.0,15.6,11.2,8.4,9.4,9.6,8.8,9.2,11.6,10,13.6,11.2,
80,90,81,78,88,88,82,78,127,87,83,80,95,81,89,81,63},
*data1,       // Корреляционная матрица, затем
                      // редуцированная корреляционная матрица
        *t,           // Матрица факторного отображения
        *s,           // Дисперсии
        buf;          // Рабочая переменная
 
 data1 = new double [k * k];
 t = new double [k * k];
 s = new double [k];
 
 ////////////////////////////////////
 // Вычисление корреляционной матрицы
 if (!LikenessForCorrelation (z,data1,n,k,0))
   {
    cout << "Корреляционная матрица\n";
    for (i = 0,i1 = 0; i < k; i++)
      {
       for (j = 0; j < k; j++,i1++)
         cout << setw (10) << data1[i1];
       cout << endl;
      }
 
if (!(Code = MaximumLikelihood (data1,k,t,s,Factor,&m)))
      {
       ///////////////////////
       // Вычисленные общности
       cout << "Оценки общности:\n";
       for (i = 0; i < k; i++ )
         cout << (i + 1) << " = " << s[i] << endl;
 
       ////////////////////////////////////////
       // Редуцированная корреляционная матрица
       for (i = 0,i1 = 0; i < k; i++,i1 += k + 1)
         data1[i1] = s[i];
 
       ////////////////////////////////////////
       // Оценка выделенной факторами дисперсии
       PercentOfVariance (data1,k,t,s,m);
       cout << "Выделенные дисперсии:\n";
       for (i = 0, buf = 0; i < m; i++ )
         {
          buf += s[i];
          cout << setw (3) << (i + 1) << " = " << setw (8)
               << s[i] << "%, всего = " << buf << "%\n";
         }
 
       /////////////////////////////////
       // Матрица факторного отображения
       cout << "Матрица факторного отбражения\n";
       for (i = 0; i < k; i++)
         {
          for (j = 0,i1 = i; j < m; j++,i1 += k)
            cout << setw (14) << t[i1];
          cout << endl;
         }
 
       ////////////////////
       // Варимакс—вращение
       if (m > 2)
         {
          if (!Varimax (t,k,m))
            {
             cout   << "Повернутая матрица факторного "
    << "отбражения\n";
             for (i = 0; i < k; i++)
               {
                for (j = 0,i1 = i; j < m; j++, i1 += k)
                  cout << setw (14) << t[i1];
                cout << endl;
               }
            }
          else
            cout << "Мало памяти\n";
         }
      }
    else if (Code == —1)
      cout << "Мало памяти\n";
    else
      cout << "Ошибка в вычислениях\n";
   }
 else
   cout << "Мало памяти\n";
 
 delete [] data1; delete [] t; delete [] s;
}
 
int MaximumLikelihood (double z[],int k,double r[],double b[],int mz,int *ms)
//
// Функция производит факторный анализ методом максимума
// правдоподобия.
// Обозначения:
//    z — нередуцированная корреляционная матрица,
//    k — размер корреляционной матрицы,
//    r — матрица факторного отображения размером не менее k * k,
//    b — вычисленный вектор общностей,
//   mz — заданное число факторов,
//  *ms — вычисленное число факторов.
// Примечание:
//  если заданное число факторов велико, оно корректируется.
// Возвращаемое значение:
//   0 при нормальном окончании счета,
//  —1 при недостатке памяти для рабочих массивов,
//  —2 при ошибке в вычислениях.
//
{
 register int i; // Счетчик цикла
 
 int m,          // Число факторов
     Code,       // Код ошибки
     m1;         // Счетчик одномерного массива
 double *a,*am,  // Факторная матрица
        *d,*dm,  // Матрица характерностей и обратная ей
        *t,      // Вспомогательная матрица
        buf;     // Сумма для проверки сходимости
 
 /////////////////////////////////
// Вычисление m главных компонент
 if ((Code = PrincipalFactor (z,k,r,&m)) != 0)
   return Code;
 
 if ((a = new double[k * k]) == 0)
   return —1;
 if ((am = new double[k * k]) == 0)
   {
    delete [] a;
    return —1;
   }
 if ((d = new double[k * k]) == 0)
   {
    delete [] a; delete [] am;
    return —1;
   }
 if ((dm = new double[k * k]) == 0)
   {
    delete [] a; delete [] d; delete [] am;
    return —1;
   }
 if ((t = new double[k * k]) == 0)
   {
    delete [] a; delete [] d; delete [] dm; delete [] am;
    return —1;
   }
 
 ///////////////////////////////
 // Корректировка числа факторов
 if (mz < m && mz > 0)
   {
    // Заданное количество факторов
    *ms = mz;
    m = mz;
   }
 else
   // Вычисленное количество факторов
   *ms = m;
 
 FillUp (b,k,1);
 
 //////////////////////////////////////////////
 // Начало итераций — матрица главных компонент
 ArrayToArray (r,am,k * m);
 
 do
   {
    /////////////////////////////////////////
    // Матрица A для следующего шага итераций
    // Здесь a — матрица A(i — 1/2), как альтернативу
    // можно применить функцию ArrayToArray
    for (i = 0; i < k * m; i++)
      a[i] = am[i];
 
    ////////////////////////////////
    // Определение матрицы общностей
    MatrixMultiplyMatrixT (a,a,d,k,m,k);
 
    for (i = 0, m1 = 0; i < k; i++, m1 += k + 1)
      {
       //////////////////////////////
       // Вектор общностей для вывода
       b[i] = d[m1];
 
       ///////////////////////////
       // Матрица характерностей D
       d[m1] = 1 — d[m1];
      }
 
    //////////////////////////////////////////////////
    // Определение обратной матрицы характерностей DM
    if ((Code = InverseMatrix (d,dm,k)) != 0)
      {
       delete [] d; delete [] t; delete [] dm; delete [] am;
       delete [] a;
       return Code;
      }
 
    /////////////////////////////////
    // Определение матрицы J(i — 1/2)
 
    // Здесь d — матрица J(i — 1/2)
    MatrixTMultiplyMatrix (a,dm,t,m,k,k);
    MatrixMultiplyMatrix (t,a,d,m,k,m);
 
    /////////////////////////////////////////////////////////
    // Вращение матрицы J(i — 1/2) — определение матрицы J(i)
    // Здесь t — матрица вращения Q
    //       d — матрица J(i)
    if ((Code = Jacobi (d,m,0.000001,&m1,t)) != 0)
      {
       delete [] d; delete [] t; delete [] dm; delete [] am;
       delete [] a;
       return Code;
      }
 
/////////////////////////////////////
    // Определение факторной матрицы A(i)
    MatrixMultiplyMatrix (a,t,r,k,m,m);
 
    ////////////////////////////////////
    // Определение обратной матрицы J(i)
    // Здесь t — обратная матрица J(i)
    if ((Code = InverseMatrix (d,t,m)) != 0)
      {
       delete [] d; delete [] t; delete [] dm; delete [] am;
       delete [] a;
       return Code;
      }
 
    /////////////////////////////////
    // Определение матрицы A(i + 1/2)
    // Здесь am — матрица A(i + 1/2)
    MatrixMultiplyMatrix (z,dm,am,k,k,k);
    for (i = 0, m1 = 0; i < k; i++, m1 += k + 1)
      am[m1] —= 1;
    MatrixMultiplyMatrix (am,r,d,k,k,m);
    MatrixMultiplyMatrix (d,t,am,k,m,m);
 
    ////////////////////////////
    // Условие окончания расчета
    for (i = 0, buf = 0; i < k * m; i++)
      buf += fabs (am[i] — a[i]);
 
   } while (buf < 0.001);
 
 delete [] d; delete [] t; delete [] dm; delete [] am;
 delete [] a;
 
 return 0;
}

07_02.txt

C++

Пример применения
int Reduction (double z[], double r[],int k,int Mode)
//
// Функция производит редукцию корреляционной матрицы.
// Обозначения:
//     z — корреляционная матрица,
//     r — редуцированная корреляционная матрица,
//     k — размерность корреляционной матрицы,
//  Mode — метод вычисления общностей:
//       = 0 — анализ главных компонент,
//       = 1 — способ наибольшей корреляции,
//       = 2 — коэффициент множественной корреляции,
//       = 3 — средние коэффициенты корреляции,
//       = 4 — метод триад.
// Возвращаемое значение:
//   0 при нормальном окончании расчета.
//  —1 при недостатке памяти,
//  —2 при ошибке в параметрах, например k >= 3 для метода триад.
//
{
 register int i,j; // Счетчики
 
 int m,m1,k1,k2;   // Счетчики одномерного массива
 
 double *t,        // Вспомогательный массив
        s,s1,s2;   // Вспомогательные переменные
 
 if ((t = new double[k * k]) == 0)
   return —1;
 
 ///////////////////////////////
 // Копия корреляционной матрицы
 ArrayToArray (z,r,k * k);
 
 ////////////////////////
 // Определение общностей
 switch (Mode)
   {
    case 0:
      //////////////////////////////////////////
      // Нет редукции — анализ главных компонент
      break;
    case 1:
      ///////////////////////////////
// Способ наибольшей корреляции
      for (i = 0, m = 0, m1 = 0; i < k; i++)
        {
         for (j = 0; j < k; j++, m++)
           t[j] = i == j ? 0 : fabs (z[m]);
         r[m1] = MaximumOf (t,k);
         m1 += k + 1;
        }
      break;
    case 2:
      ///////////////////////////////////////
      // Коэффициент множественной корреляции
      if (InverseMatrix (r,t,k) == 0)
        for (i = 0, m = 0; i < k; i++,m += k + 1)
          if (t[m] != 0 || t[m] != 1)
            r[m] = 1 — 1 / t[m];
      break;
    case 3:
      //////////////////////////////////
      // Средние коэффициенты корреляции
      for (i = 0, m = 0, m1 = 0; i < k; i++,m1 += k + 1)
        {
         for (j = 0, r[m1] = 0; j < k; j++, m++)
           r[m1] += i == j ? 0 : fabs (z[m]);
         r[m1] /= k — 1;
        }
      break;
    default:
      //////////////
      // Метод триад
      if (k < 3)
        {
         delete [] t;
         return —2;
        }
 
      for (i = 0, m = 0, m1 = 0; i < k; i++,m1 += k + 1)
        {
         //////////////////////////////////
         // Поиск двух максимумов в столбце
         for (j = 0; j < k; j++)
           t[j] = fabs (z[m++]);
         t[i] = 0;
         s1 = MaximumOf (t,k,&k1);
         t[k1] = 0;
         s2 = MaximumOf (t,k,&k2);
 
         /////////////////////////////////////////////
         // Корреляция между максимальными параметрами
         s = fabs (z[k1 + k2 * k]);
         if (s != 0)
           r[m1] = s1 * s2 / s;
        }
   }
 
 delete [] t;
 
 return 0;
}

07_01.txt

C++

Исходные коды и пример применения
#include <fstream.h>
#include <iomanip.h>
#include <math.h>
 
#include "megastat.h"
 
void main (void)
{
 char *ReduceName[] = {"нет редукции (главные компоненты)\n",
                       "способ наибольшей корреляции\n",
                       "коэффициент множественной корреляции\n",
                       "средние коэффициенты корреляции\n",
                         "метод триад\n"};
 
 register int i,j,i1;  // Счетчики
 
 int Code,             // Код ошибки
     Communality = 4,  // Код оценки общности
     n = 17,           // Число объектов
     k = 12,           // Число параметров
     m,                // Вычисленное количество факторов
     Factor = 4;       // Заданное пользователем число факторов
 
 double z[] = {        // Исходные данные
9.1,9.2,6.6,6.5,8.6,4.7,7.9,4.9,4.0,5.1,4.0,5.3,6.0,8.5,4.2,8.0,10.9,
33,29,29,27,27,17,23,27,32,21,27,24,20,30,21,26,24,
0.44,1.54,0.82,0.63,0.78,0.15,0.42,0.43,0.7,0.51,0.3,0.43,0.41,1,0.5,1.1,1.2,
23,58,43,36,34,19,23,26,54,51,24,34,34,40,57,50,45,
0.48,0.96,0.59,0.51,0.62,0.5,0.4,0.63,0.58,0.43,0.4,0.47,0.37,0.9,0.37,0.85,1.1,
25,36,31,29,27,63,21,38,46,40,38,37,31,34,42,41,41,
0.03,0.08,0.06,0.05,0.07,0.024,0.05,0.05,0.02,0.03,0.02,0.04,0.04,0.1,0.053,0.1,0.05,
2,3,3,3,3,3,3,3,2,3,2,3,3,4,6,5,2,
1.55,1.2,3.4,3.8,1.6,7.0,1.4,1.0,1.05,2.3,3.5,6.0,1.1,0.98,1.6,2.3,5.9,
0.78,0.62,1.08,1.92,0.61,1.6,1.0,1.44,1.44,4.8,2.0,4.4,1.28,0.96,0.68,0.72,1.04,
9.2,7.4,12,12.6,6.72,16.0,15.6,11.2,8.4,9.4,9.6,8.8,9.2,11.6,10,13.6,11.2,
80,90,81,78,88,88,82,78,127,87,83,80,95,81,89,81,63},
        *data1,        // Корреляционная матрица
        *data2,        // Редуцированная корреляционная матрица
        *t,            // Матрица факторного отображения
        *s,            // Дисперсии
        buf;           // Рабочая переменная
 
 data1 = new double [k * k];
 data2 = new double [k * k];
 t = new double [k * k];
 s = new double [k];
 
 ////////////////////////////////////
 // Вычисление корреляционной матрицы
 if (!LikenessForCorrelation (z,data1,n,k,0))
   {
    cout << "Корреляционная матрица\n";
    for (i = 0,i1 = 0; i < k; i++)
      {
       for (j = 0; j < k; j++,i1++)
         cout << setw (10) << data1[i1];
       cout << endl;
      }
 
    //////////////////////////////////
    // Редукция корреляционной матрицы
    if (!(Code = Reduction (data1,data2,k,Communality)))
      {
       cout << "Метод оценки общности: " << ReduceName[Communality];
       if (Communality != 0)
         {
          cout << "Оценки общности:\n";
          for (i = 0,i1 = 0; i < k; i++,i1 += k + 1)
            cout << (i + 1) << " = " << data2[i1] << endl;
         }
 
       ///////////////////
       // Факторный анализ
       if (!(Code = PrincipalFactor (data2,k,t,&m)))
         {
          cout << "Число выделенных факторов " << m << endl;
 
          ///////////////////////////////////////////////////
          // Коррекция числа факторов по желанию пользователя
          if (0 < Factor && Factor < m)
            {
             m = Factor;
             cout << "Заданное число факторов " << m << endl;
            }
 
          ////////////////////////////////////////
          // Оценка выделенной факторами дисперсии
          PercentOfVariance (data2,k,t,s,m);
          cout << "Выделенные дисперсии:\n";
          for (i = 0,buf = 0; i < m; i++)
            {
             buf += s[i];
              cout << setw (3) << (i + 1) << " = "
           << setw (8) << s[i] << "%, всего = " << buf << "%\n";
            }
 
          /////////////////////////////////
          // Матрица факторного отображения
          cout << "Матрица факторного отображения\n";
          for (i = 0; i < k; i++)
            {
             for (j = 0,i1 = i; j < m; j++,i1 += k)
               cout << setw (14) << t[i1];
             cout << endl;
            }
 
          ////////////////////
          // Варимакс—вращение
          if (m > 2)
            {
             cout   << "Повернутая матрица факторного "
    << "отображения\n";
             if (!Varimax (t,k,m))
               {
                for (i = 0; i < k; i++)
                  {
                   for (j = 0,i1 = i; j < m; j++,i1 += k)
                     cout << setw (14) << t[i1];
                   cout << endl;
                  }
               }
             else
cout << "Мало памяти\n";
            }
         }
       else if (Code == —1)
         cout << "Мало памяти\n";
       else
         cout << "Ошибка при вычислении\n";
      }
    else if (Code == —1)
      cout << "Мало памяти\n";
    else
      cout << "Ошибка при редукции\n";
   }
 else
   cout << "Мало памяти\n";
 
 delete [] data1; delete [] data2; delete [] t; delete [] s;
}
 
int PrincipalFactor (double z[],int k,double r[],int *m)
//
// Функция производит факторный анализ методом главных факторов.
// Обозначения:
//   z — корреляционная матрица,
//   k — порядок корреляционной матрицы,
//   r — матрица факторного отображения размером не менее k * k,
//  *m — число факторов.
// Возвращаемое значение:
//   0 при нормальном окончании счета,
//  —1 при недостатке памяти для рабочих массивов,
//  —2 при ошибке в вычислениях.
//
{
 register int i,j; // Счетчики
 
 int m1,m2,Code;   // Вспомогательная переменная
 
 double *z1,       // Рабочая копия корреляционной матрицы
        save;      // Буфер
 
 *m = 0;
 
 if ((z1 = new double[k * k]) == 0)
   return —1;
 ///////////////////////////////////////
 // Рабочая копия корреляционной матрицы
 ArrayToArray (z,z1,k * k);
 
 ////////////////////////////
 // Решение проблемы факторов
 if ((Code = Jacobi (z1,k,0.000001,&m1,r)) != 0)
   {
    delete [] z1;
    return Code;
   }
 /////////////////////////////////////////////////
 // Упорядочивание собственных значений и векторов
 for (i = 1; i < k; i++)
   z1[i] = z1[i * (k + 1)];  // Первый столбец —
                             // собственные значения
 
for (i = 0; i < k; i++)
   {
    Code = i;
    save = z1[i];
    for (j = i + 1; j < k; j++)
      if (save < z1[j])
        {
         Code = j;
         save = z1[j];
        }
 
    ColInterchange (z1,1,i,Code);
    ColInterchange (r,k,i,Code);
   }
 
 /////////////////////////////
 // Отбор собственных значений
 for (i = 0, m1 = 0; i < k; i++)
   if (z1[i] < 0)
     break;
   else
     {
      (*m)++;
 
      ////////////////////////////////////////////
      // Вычисление матрицы факторного отображения
      save = sqrt (z1[i]);
      for (j = 0; j < k; j++, m1++)
        r[m1] *= save;
     }
 
 delete [] z1;
 
 return 0;
}

@madbounce · 07.04.2013, 12:06 **[ТС]**

Сообщение от anonymous2797

madbounce, но ведь в .h только прототипы функций.

К сожалению я не могу что-то сказать, т.к. опять же плохо разбираюсь в С. Я написал уже и издательству, и куда только можно.
Пока что пытаюсь хоть что-то запустить. Если это возможно

@VladislavTepes · 07.04.2013, 12:19

madbounce, без .lib вряд ли что-то получится.

iifat · 07.04.2013, 12:27

Сообщение от anonymous2797

если есть .h, значит, где-то и .lib должен быть

.c или .cpp. Это ж всё-таки книжка.

@VladislavTepes · 07.04.2013, 12:30

iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю).

@madbounce · 07.04.2013, 12:33 **[ТС]**

Сообщение от iifat

.c или .cpp. Это ж всё-таки книжка.

Ну автор говорит во введении что у него из исходников есть и С++ и С и Perl, ну в общем что на чем.

Добавлено через 2 минуты

Сообщение от anonymous2797

iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю).

Ага вот на сайте издательства "Файлы к книге". http://piter.com/book.phtml?978531800220
Тут исходники по главам.

@VladislavTepes · 07.04.2013, 12:45

madbounce, там и поищите.

@madbounce · 07.04.2013, 12:54 **[ТС]**

Сообщение от anonymous2797

madbounce, там и поищите.

Та вот отсюда же и брал.

@gazlan · 07.04.2013, 18:26

Сообщение от madbounce

Взял это из книги И.Гайдышев "Анализ и обработка данных"

А каких не хватает файлов ?

А... Видел как-то. Книга, кстати, показалась неплохой.

Ну, так даже в архиве с сайта издательства http://www.piter.com/upload%2F... Flists.zip нужных файлов нет.

Раз уж вы ее все равно читаете, посмотрите, может быть есть их листинги в самой книжке. Если нет - только к автору.

Добавлено через 59 минут
Upd:

Проверил еще раз по списку - точно не хватает вот этой функции:

C++

1	int LikenessForCorrelation (double,double,int,int,int);

Другие имена есть в коде к другим главам, но неизвестно, не потянут ли они новых зависимостей.
Позднее, попробую скомпилировать и отпишусь здесь.

@gazlan · 08.04.2013, 04:49

Гм. До сих пор, я был лучшего мнения об издательстве "Питер".

Собственно, небрежность и отсутствие вычитки чувствуются во всем.
Даже такое известное имя, как Hamming (метрика Хэмминга), написано с
орфографической ошибкой.

Очевидно, что этот код - прилагаемый к книге - НИКОГДА не проверялся и
НИКОГДА не компилировался.

Его просто невозможно скомпилировать - и из-за огромного количества
типографских ошибок, и из-за отсутствия некоторых модулей, которые
пришлось перепечатывать из DJVU-копии книги.

И вот, сделано, наконец, то, что давно должен был сделать если и не автор,
то, хотя бы, рецензент или технический редактор - скомпилировано "это".

Вероятно, "это" следует поместить в какой-нибудь раздел "антипаттерны".
Давненько я не видел такого похабного кода. К сожалению, глупостей
понаписано столько, что нет никакой возможности выправить за один раз все,
и нет никакой уверенности, что удастся заставить "это" работать.
(Оно запускается и что-то считает, но я не пытался проверить правильность).

Судя по использованию 'cout' и перегруженных функций (тогда почему бы уж
не Templates взамен Copy/Paste кода под каждый новый тип?), автору,
вероятно, казалось, что он пишет на C++.

На самом деле, это код "не тянет" даже на Basic. Копирование массивов
(POD-типа), например, выполняется в цикле. Взамен собственных функций
сортировки, вероятно, следовало бы вызывать qsort(), но я поленился с этмим
разбираться.

Стиль форматирования лучше всего охарактеризовать как "отвратительный".
Точнее сказать, он везде разный - никакого единого стиля нет - но везде
отвратительный.

Внешне неразличимые символы - такие как 1 и l, например, всюду используются
совместно. Исключая названия функций, ни одного осмысленного наименования
код не содержит. Где-то пропущены скобки или точка с запятой - восстановил,
где-то, возможно, что-то более существенное. В одном месте локальная в блоке
переменная перекрывала другую с тем же именем, но из внешнего блока.
Заметить удалось только благодаря разнице в типах (из-за ошибки инициализации).
Сколько еще такого осталось незамеченным - бог знает.

Понятно, что такой грязный код нуждается в тотальном тестировании.

Глупейшая экономия на всем - на пробелах, на пустых строках, на скобках
(отличный тест на запоминание приоритетов всех операций). Декларации
лепятся в одну строку, инициализации - в заголовок цикла, присваивания -
в условие оператора if, переменные, за редким ислючением, никогда не
инициализуются, а иногда, даже, и не используются.

Автор, очевидно, не понимает ни разницы между целым и действительным типом
переменных, ни разницы между целыми и указателями. Числа с плавающей точкой
регулярно проверяются на точное равенство целому нулю, а если и
инициализируются - то, опять же, целыми значениями.

Компилятор выдает множество предупреждений о возможном использовании
переменных без инициализации.

Who care?

Про булевские переменные автор, вероятно, никогда не слышал, и всюду наглядно
использует 0 и -1.

Ну, и за однобуквенные идентификаторы, надо просто давать срок.

Использование метода Якоби для вычисления собственных значений (вместо
SVD), и инвертирование по Гауссу, а не по Пенроузу-Муру, мне кажется
сомнительным.

Откровенно говоря, все это было бы проще написать заново.

@madbounce · 29.04.2013, 21:51 **[ТС]**

Обновление по теме. В общем один очень хороший человек, помог создать библиотеку при подключении к которой можно теоретически запустить любую программу из книги. Отдельно спасибо т-щу gazlan за помощь. Спасибо огромное за рабочий код, большое спасибо. Очень-очень Вам благодарен!!!

@madbounce 1 / 1 / 0 Регистрация: 20.04.2012 Сообщений: 24
	07.04.2013, 12:06 [ТС]	21
	Сообщение от anonymous2797 madbounce, но ведь в .h только прототипы функций. К сожалению я не могу что-то сказать, т.к. опять же плохо разбираюсь в С. Я написал уже и издательству, и куда только можно. Пока что пытаюсь хоть что-то запустить. Если это возможно 0

@VladislavTepes 80 / 80 / 14 Регистрация: 27.06.2012 Сообщений: 555 Записей в блоге: 1
	07.04.2013, 12:19	22
	madbounce, без .lib вряд ли что-то получится. 0

iifat 2719 / 1773 / 187 Регистрация: 05.06.2011 Сообщений: 5,132
	07.04.2013, 12:27	23
	Сообщение от anonymous2797 если есть .h, значит, где-то и .lib должен быть .c или .cpp. Это ж всё-таки книжка. 0

@VladislavTepes 80 / 80 / 14 Регистрация: 27.06.2012 Сообщений: 555 Записей в блоге: 1
	07.04.2013, 12:30	24
	iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю). 0

@madbounce 1 / 1 / 0 Регистрация: 20.04.2012 Сообщений: 24
	07.04.2013, 12:33 [ТС]	25
	Сообщение от iifat .c или .cpp. Это ж всё-таки книжка. Ну автор говорит во введении что у него из исходников есть и С++ и С и Perl, ну в общем что на чем. Добавлено через 2 минуты Сообщение от anonymous2797 iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю). Ага вот на сайте издательства "Файлы к книге". http://piter.com/book.phtml?978531800220 Тут исходники по главам. 0

@VladislavTepes 80 / 80 / 14 Регистрация: 27.06.2012 Сообщений: 555 Записей в блоге: 1
	07.04.2013, 12:45	26
	madbounce, там и поищите. 0

@madbounce 1 / 1 / 0 Регистрация: 20.04.2012 Сообщений: 24
	07.04.2013, 12:54 [ТС]	27
	Сообщение от anonymous2797 madbounce, там и поищите. Та вот отсюда же и брал. 0