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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Идентификатор не определён (работа с файлами заголовка, модульное программирование) http://www.cyberforum.ru/cpp-beginners/thread830022.html
У меня есть класс в файле имя_класса.h Есть реализация методов, конструктора и деструктора в файле имя_класса.cpp Другой файл 3.cpp содержит функцию main. Когда я в ней пишу имя класса, чтобы объявить объект, visual studio 2010 мне его подчёркивает. Ошибка такая: "Идентификатор "имя_класса" не определён". Подскажите что надо сделать, чтобы он определился:)
C++ Использование функций Windows Script Host в проекте на С/С++ Доброе время суток! Возник вопрос, а можно ли использовать фукции Windows Script Host в проекте на С/С++, ассемблерные вставки же там существуют, а как дело с Wsh? http://www.cyberforum.ru/cpp-beginners/thread830012.html
Проверка бинарного отношения на функцию C++
Ребят,помогите, пожалуйста, с лабой по дискретной математике. третью неделю голову ломаю, ничего в голову не приходит вообще. Собстна задание: Задать бинарное отношение. Определить, является ли оно функцией. Если является, то определить какая это функция: инъективная, сюръективная, биективная
C++ Не создавая дополнительные массивы, определить какой из элементов потовторяется в последовательсности А1,А2,...Аn., наибольшее число раз
Напишите программу,в которой создается одномерный массив натуральных чисел А1,А2......Аn(n=10). Не создавая дополнительные массивы, определить какой из элементов потовторяется в последовательсности А1,А2,...Аn., наибольшее число раз, и найти его порядковый номер, ближайший к началу последовательности. Не могу понять задачу. :(
C++ exe файл visual studio http://www.cyberforum.ru/cpp-beginners/thread829980.html
здравствуйте, как сделать так, чтобы мой ехе файл созданный в VS_2010 работал на другой машине под управлением виндоус ? заранее спасибо )
C++ Переставить местами строки с наименьшей и наибольшей суммами элементов Задача. Переставить местами строки с наименьшей и наибольшей суммами элементов. Нужен код. На мове С++ подробнее

Показать сообщение отдельно
madbounce
0 / 0 / 0
Регистрация: 20.04.2012
Сообщений: 24
06.04.2013, 21:15     Удачно откомпилировать исходлник
Ребят, всем привет. Хотел обратиться к Вам с такой просьбой. Мало знаком с "сишкой", так вот нарыл исходники по нужной мне теме, я так понял на с++ . Так вот чет промаялся день, хотел откомпилить на старом компляторе 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;
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 20:32. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru