Форум программистов, компьютерный форум CyberForum.ru

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

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

megastat.txt
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
//Исходные коды
// 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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Исходные коды
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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
Исходные коды
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)
   return1;
 
 //////////////////////////////////
 // Нормализация факторных нагрузок
 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;
    return1;
   }
 if ((y = new double[k * 2]) == 0)
   {
    delete [] x;
    return1;
   }
 
 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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
Исходные коды и пример применения
#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)
   return1;
 if ((r1 = new double[n * n]) == 0)
   {
    delete [] r;
    return1;
   }
 if ((b = new double[n]) == 0)
   {
    delete [] r; delete [] r1;
    return1;
   }
 if ((sign = new int[n]) == 0)
   {
    delete [] r; delete [] r1; delete [] b;
    return1;
   }
 
 ////////////////////////////////////
 // Начальные значения массива знаков
 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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
Исходные коды и пример применения
#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)
   return1;
 if ((am = new double[k * k]) == 0)
   {
    delete [] a;
    return1;
   }
 if ((d = new double[k * k]) == 0)
   {
    delete [] a; delete [] am;
    return1;
   }
 if ((dm = new double[k * k]) == 0)
   {
    delete [] a; delete [] d; delete [] am;
    return1;
   }
 if ((t = new double[k * k]) == 0)
   {
    delete [] a; delete [] d; delete [] dm; delete [] am;
    return1;
   }
 
 ///////////////////////////////
 // Корректировка числа факторов
 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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
Пример применения
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)
   return1;
 
 ///////////////////////////////
 // Копия корреляционной матрицы
 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] = 11 / 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;
         return2;
        }
 
      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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
Исходные коды и пример применения
#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)
   return1;
 ///////////////////////////////////////
 // Рабочая копия корреляционной матрицы
 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;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
06.04.2013, 21:15     Удачно откомпилировать исходлник
Посмотрите здесь:

C++ не могу откомпилировать
помогите откомпилировать! C++
C++ помогите откомпилировать!
C++ не могу откомпилировать
C++ не могу откомпилировать программу C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
madbounce
0 / 0 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 12:06  [ТС]     Удачно откомпилировать исходлник #21
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, но ведь в .h только прототипы функций.
К сожалению я не могу что-то сказать, т.к. опять же плохо разбираюсь в С. Я написал уже и издательству, и куда только можно.
Пока что пытаюсь хоть что-то запустить. Если это возможно
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
VladislavTepes
 Аватар для VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 12:19     Удачно откомпилировать исходлник #22
madbounce, без .lib вряд ли что-то получится.
iifat
2179 / 1332 / 96
Регистрация: 05.06.2011
Сообщений: 3,689
07.04.2013, 12:27     Удачно откомпилировать исходлник #23
Цитата Сообщение от anonymous2797 Посмотреть сообщение
если есть .h, значит, где-то и .lib должен быть
.c или .cpp. Это ж всё-таки книжка.
VladislavTepes
 Аватар для VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 12:30     Удачно откомпилировать исходлник #24
iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю).
madbounce
0 / 0 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 12:33  [ТС]     Удачно откомпилировать исходлник #25
Цитата Сообщение от iifat Посмотреть сообщение
.c или .cpp. Это ж всё-таки книжка.
Ну автор говорит во введении что у него из исходников есть и С++ и С и Perl, ну в общем что на чем.

Добавлено через 2 минуты
Цитата Сообщение от anonymous2797 Посмотреть сообщение
iifat, человек вроде как говорил, что там какой-то хидер есть (в приложении к книжке или на сайте, не знаю).
Ага вот на сайте издательства "Файлы к книге". http://piter.com/book.phtml?978531800220
Тут исходники по главам.
VladislavTepes
 Аватар для VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 12:45     Удачно откомпилировать исходлник #26
madbounce, там и поищите.
madbounce
0 / 0 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 12:54  [ТС]     Удачно откомпилировать исходлник #27
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, там и поищите.
Та вот отсюда же и брал.
gazlan
2855 / 1803 / 271
Регистрация: 27.08.2010
Сообщений: 4,883
Записей в блоге: 1
07.04.2013, 18:26     Удачно откомпилировать исходлник #28
Цитата Сообщение от madbounce Посмотреть сообщение
Взял это из книги И.Гайдышев "Анализ и обработка данных"
А каких не хватает файлов ?
А... Видел как-то. Книга, кстати, показалась неплохой.

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

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

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

Проверил еще раз по списку - точно не хватает вот этой функции:
C++
1
int LikenessForCorrelation (double*,double*,int,int,int);
Другие имена есть в коде к другим главам, но неизвестно, не потянут ли они новых зависимостей.
Позднее, попробую скомпилировать и отпишусь здесь.
gazlan
2855 / 1803 / 271
Регистрация: 27.08.2010
Сообщений: 4,883
Записей в блоге: 1
08.04.2013, 04:49     Удачно откомпилировать исходлник #29
Гм. До сих пор, я был лучшего мнения об издательстве "Питер".

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

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

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

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

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

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

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

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

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

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

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

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

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

Who care?

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

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

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

Откровенно говоря, все это было бы проще написать заново.
Вложения
Тип файла: rar stat.rar (27.4 Кб, 42 просмотров)
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
29.04.2013, 21:51     Удачно откомпилировать исходлник
Еще ссылки по теме:

Откомпилировать C++
C++ не получается откомпилировать
Не могу откомпилировать C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
madbounce
0 / 0 / 0
Регистрация: 20.04.2012
Сообщений: 24
29.04.2013, 21:51  [ТС]     Удачно откомпилировать исходлник #30
Обновление по теме. В общем один очень хороший человек, помог создать библиотеку при подключении к которой можно теоретически запустить любую программу из книги. Отдельно спасибо т-щу gazlan за помощь. Спасибо огромное за рабочий код, большое спасибо. Очень-очень Вам благодарен!!!
Вложения
Тип файла: rar megastat.rar (45.5 Кб, 36 просмотров)
Yandex
Объявления
29.04.2013, 21:51     Удачно откомпилировать исходлник
Ответ Создать тему
Опции темы

Текущее время: 00:23. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru