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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 14, средняя оценка - 4.93
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
#1

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

06.04.2013, 21:15. Просмотров 1826. Ответов 29
Метки нет (Все метки)

Ребят, всем привет. Хотел обратиться к Вам с такой просьбой. Мало знаком с "сишкой", так вот нарыл исходники по нужной мне теме, я так понял на с++ . Так вот чет промаялся день, хотел откомпилить на старом компляторе 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++
Здаствуйте:) Можете откомпилировать программу и выслать файл PSDP В строке &quot;vvedite razmer PSDP v megobaitah&quot; введите &quot;1&quot;. Заранее...

не могу откомпилировать - C++
подскажите как перевестити .cpp файл в EXE. я юзаю Dev-C++

помогите откомпилировать! - C++
Помогите пожалуйста откопмилировать! #include &lt;stdafx.h&gt; #include &lt;iostream&gt; #class TA{ int a; int b; ...

помогите откомпилировать! - C++
помогите пожалуйста откомпилировать! #include &lt;stdafx.h&gt; #include &lt;iostream&gt; #class TA{ int a; int b; ...

Откомпилировать сорсы - C++
Здравствуйте. Помогите пожалуйста. Необходимо откомпилировать сорсы. Имеем win7x64 vs2015 и сами сорсы созданные в более ранней...

не могу откомпилировать - C++
Такая проблема: При компиляции появляется сообщение «Не удается найти указанный файл». Что бы я не ввёл, даже если в коде нет абсолютно...

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
gazlan
3131 / 1906 / 285
Регистрация: 27.08.2010
Сообщений: 5,132
Записей в блоге: 1
07.04.2013, 00:38 #2
И где вы это взяли?

Грязный студенческий код с кучей типографских ошибок. + в вашем пакете не хватает файлов:

C++
1
2
3
4
5
6
7
8
9
10
11
Linking...
07_01_main.obj : error LNK2001: unresolved external symbol "int __cdecl LikenessForCorrelation(double *,double *,int,int,int)" (?LikenessForCorrelation@@YAHPAN0HHH@Z)
07_01_main.obj : error LNK2001: unresolved external symbol "void __cdecl ColInterchange(double *,int,int,int)" (?ColInterchange@@YAXPANHHH@Z)
07_01_main.obj : error LNK2001: unresolved external symbol "int __cdecl Jacobi(double *,int,double,int *,double *)" (?Jacobi@@YAHPANHNPAH0@Z)
07_01_main.obj : error LNK2001: unresolved external symbol "void __cdecl ArrayToArray(double *,double *,int)" (?ArrayToArray@@YAXPAN0H@Z)
07_02.obj : error LNK2001: unresolved external symbol "void __cdecl ArrayToArray(double *,double *,int)" (?ArrayToArray@@YAXPAN0H@Z)
07_05.obj : error LNK2001: unresolved external symbol "void __cdecl MatrixMultiplyMatrix(double *,double *,double *,int,int,int)" (?MatrixMultiplyMatrix@@YAXPAN00HHH@Z)
07_02.obj : error LNK2001: unresolved external symbol "double __cdecl MaximumOf(double *,int,int *)" (?MaximumOf@@YANPANHPAH@Z)
07_02.obj : error LNK2001: unresolved external symbol "int __cdecl InverseMatrix(double *,double *,int)" (?InverseMatrix@@YAHPAN0H@Z)
07_02.obj : error LNK2001: unresolved external symbol "double __cdecl MaximumOf(double *,int)" (?MaximumOf@@YANPANH@Z)
Debug/stat.exe : fatal error LNK1120: 8 unresolved externals
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 10:18  [ТС] #3
Цитата Сообщение от gazlan Посмотреть сообщение
И где вы это взяли?

Грязный студенческий код с кучей типографских ошибок. + в вашем пакете не хватает файлов:
Взял это из книги И.Гайдышев "Анализ и обработка данных"
А каких не хватает файлов ?
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 10:29 #4
madbounce, по-моему, компилировать "современный" C++ под Turbo C-махохизм. Зачем вам это понадобилось, если не секрет? Есть же куча нормальных инструметов: VC++, MinGw и т.д.
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 10:35  [ТС] #5
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, по-моему, компилировать "современный" C++ под Turbo C-махохизм. Зачем вам это понадобилось, если не секрет? Есть же куча нормальных инструметов: VC++, MinGw и т.д.
Зачем я компилировал под Turbo C ? К сожалению, знаний в С у меня с "гулькин нос", потому может и взял может самый древний и плохой компилятор Я так обрадовался когда нашел хоть какие-то исходники, что мне нужно лишь бы оно заработало, хоть бы на Turbo С.
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 10:53 #6
Цитата Сообщение от madbounce Посмотреть сообщение
К сожалению, знаний в С у меня с "гулькин нос", потому может и взял может самый древний и плохой компилятор.
Странная логика. Да, и код не на C++? Именно на C?
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 10:58  [ТС] #7
Цитата Сообщение от anonymous2797 Посмотреть сообщение
Странная логика. Да, и код не на C++? Именно на C?
Возможно ( Это все что я нашел у автора.
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 11:00 #8
madbounce, все-таки уточните по поводу языка. Да и возьмите в руки тот же VC++ 2010 Express или Code::Blocks+MinGW и попробуйте скомпилить.
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 11:07  [ТС] #9
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, все-таки уточните по поводу языка. Да и возьмите в руки тот же VC++ 2010 Express или Code::Blocks+MinGW и попробуйте скомпилить.
Я бы взял, но с ними мне еще будет труднее в плане использования. Куда подсовывать библиотеку, да и много еще чего.
По языку уточню.
Ну вот последняя моя компиляция выдала следующие строки на скрине.
Компилировал следующие строки
Кликните здесь для просмотра всего текста

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
#include <fstream.h>
#include <iomanip.h>
#include <math.h>
 
#include "megastat.h"
 
void main (void)
{
 char *ReduceName[] = {"net redukcii\n",
                       "sposob naibol'shej korreljacii\n",
                       "kojefficient mnozhestvennoj korreljacii\n",
                       "srednie kojefficienty korreljacii\n",
                         "metod triad\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 << "Korreljacionnaja matrica\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 << "Metod ocenki obshhnosti: " << ReduceName[Communality];
       if (Communality != 0)
         {
          cout << "Ocenki obshhnosti:\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 << "Chislo vydelennyh faktorov " << m << endl;
 
          ///////////////////////////////////////////////////
          // Коррекция числа факторов по желанию пользователя
          if (0 < Factor && Factor < m)
            {
             m = Factor;
             cout << "Zadannoe chislo faktorov " << m << endl;
            }
 
          ////////////////////////////////////////
          // Оценка выделенной факторами дисперсии
      PercentOfVariance (data2,k,t,s,m);
          cout << "Vydelennye dispersii:\n";
          for (i = 0,buf = 0; i < m; i++)
            {
             buf += s[i];
              cout << setw (3) << (i + 1) << " = "
           << setw (8) << s[i] << "%, vsego = " << buf << "%\n";
            }
 
          /////////////////////////////////
          // Матрица факторного отображения
          cout << "Matrica faktornogo otobrazhenija\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   << "Povernutaja matrica faktornogo "
    << "otobrazhenija\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 << "Malo pamjati\n";
        }
     }
       else if (Code == -1)
     cout << "Malo pamjati\n";
       else
     cout << "Oshibka pri vychislenii\n";
      }
    else if (Code == -1)
      cout << "Malo pamjati\n";
    else
      cout << "Oshibka pri redukcii\n";
   }
 else
   cout << "Malo pamjati\n";
 
 delete [] data1; delete [] data2; delete [] t; delete [] s;
}
 
int PrincipalFactor (double z[],int k,double r[],int *m)
//
// Функция производит факторный анализ методом главных факторов.
// Обозначения:
//   z — корреляционная матрица,
//   k — порядок корреляционной матрицы,
//   r — матрица факторного отображения размером не менее k * k,
//  *m — число факторов.
// Возвращаемое значение:
//   0 при нормальном окончании счета,
//  —1 при недостатке памяти для рабочих массивов,
//  —2 при ошибке в вычислениях.
//
{
 register int i,j; // Счетчики
 
 int m1,m2,Code;   // Вспомогательная переменная
 
 double *z1,       // Рабочая копия корреляционной матрицы
        save;      // Буфер
 
 *m = 0;
 
 if ((z1 = new double[k * k]) == 0)
   return -1;
 ///////////////////////////////////////
 // Рабочая копия корреляционной матрицы
 ArrayToArray (z,z1,k * k);
 
 ////////////////////////////
 // Решение проблемы факторов
 if ((Code = Jacobi (z1,k,0.000001,&m1,r)) != 0)
   {
    delete [] z1;
    return Code;
   }
 /////////////////////////////////////////////////
 // Упорядочивание собственных значений и векторов
 for (i = 1; i < k; i++)
   z1[i] = z1[i * (k + 1)];  // Первый столбец —
                             // собственные значения
 
for (i = 0; i < k; i++)
   {
    Code = i;
    save = z1[i];
    for (j = i + 1; j < k; j++)
      if (save < z1[j])
        {
         Code = j;
         save = z1[j];
        }
 
    ColInterchange (z1,1,i,Code);
    ColInterchange (r,k,i,Code);
   }
 
 /////////////////////////////
 // Отбор собственных значений
 for (i = 0, m1 = 0; i < k; i++)
   if (z1[i] < 0)
     break;
   else
     {
      (*m)++;
 
      ////////////////////////////////////////////
      // Вычисление матрицы факторного отображения
      save = sqrt (z1[i]);
      for (j = 0; j < k; j++, m1++)
        r[m1] *= save;
     }
 
 delete [] z1;
 
 return 0;
}
Миниатюры
Удачно откомпилировать исходлник  
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 11:12 #10
madbounce, в VC++ 2010 уже все есть, только инклуды пиши.

Добавлено через 1 минуту
madbounce, и где у вас все эти функции хранятся?
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 11:13  [ТС] #11
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, в VC++ 2010 уже все есть, только инклуды пиши.

Добавлено через 1 минуту
madbounce, и где у вас все эти функции хранятся?
Ну я так понимаю в той же библиотеке megastat.h
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 11:15 #12
madbounce, megastat.h - это нечто самописное, я так понимаю?
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 11:16  [ТС] #13
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, megastat.h - это нечто самописное, я так понимаю?
Ага. Библиотека автора.
VladislavTepes
78 / 78 / 5
Регистрация: 27.06.2012
Сообщений: 555
Записей в блоге: 1
07.04.2013, 11:17 #14
madbounce, этот файл с расширением .h у вас есть?
madbounce
1 / 1 / 0
Регистрация: 20.04.2012
Сообщений: 24
07.04.2013, 11:19  [ТС] #15
Цитата Сообщение от anonymous2797 Посмотреть сообщение
madbounce, этот файл с расширением .h у вас есть?
Ну вот: https://disk.yandex.ru/public/?hash=...MyNu0Uc6lkA%3D

Он у меня был, в TXT изначально, через Notepad++ сохранил его в MEGASTAT.H
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
07.04.2013, 11:19
Привет! Вот еще темы с ответами:

Не могу откомпилировать - C++
#include &lt;iostream&gt; #include &lt;string&gt; #include &lt;cstring&gt; //using namespace std; using std::cin; using std::cout; using...

не получается откомпилировать - C++
Есть программный код. #include &lt;iostream&gt; #include &lt;clocale&gt; #include &lt;cstdlib&gt; #include &lt;cstring&gt; // вернуть строку с...

C++ не могу откомпилировать программу - C++
Всем привет помогите плиз с проблемой начал учить язык по книге пользуюсь Microsoft Visual Stusio 2012 написал такой код /*Sample.cpp*/ ...

Не получается откомпилировать из исходников. - C++
Во общем ситуация такая шеф поставил задачу написать программу под нужды компании, разуиеется c++ я в глаза не видел, но раз надо значит...


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

Или воспользуйтесь поиском по форуму:
Yandex
Объявления
07.04.2013, 11:19
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru