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

Нужно разобрать код! - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Кросс компилятор http://www.cyberforum.ru/cpp-beginners/thread740426.html
народ , подскажите название кросс компилятора , который позволит мне перевести текст проги с C++ на Accembler P.S. заранее благодарочка
C++ Использование процедур Даны действительные числа a0...a6. Получить для x=1,3,4 значения p(x+1)-p(x), где p(y)=a6*pow(y,6)+a5*pow(y,5)+a4*pow(y,4)+a3*pow(y,3)+a2*pow(y,2)+a1*pow(y,1)+a0. Добавлено через 42 секунды Вот что смог написать: #include <stdio.h> #include <stdlib.h> #include <math.h> int fun(int y) {int a6,a5,a4,a3,a2,a1,a0; http://www.cyberforum.ru/cpp-beginners/thread740419.html
C++ Сортировка по элементам столбцов двумерного массива
Помогите решить задачу : Даны три матрицы целого типа произвольной размерности (размерность вводится пользователем). Для каждой матрицы отсортировать столбцы в порядке возрастания их максимальных элементов. Или подскажите где почитать про сортировку вообще на С, не могу ничего толкового найти.
Транспонирование матрицы C++
Товарищи! выручайте, написал программу для транспонирования матрицы, а вместо нужных значений - выводятся нули( подскажите, где ошибка ? что исправить нужно.. программа: #include<stdio.h> #include<conio.h> #include<math.h> int main() { float a, b; int i, j;
C++ Вычислить среднее арифметическое положительных и отрицательных элементов третьего столбца матрицы http://www.cyberforum.ru/cpp-beginners/thread740394.html
Весь семестр программировали на Бейсике и вдруг преподу пришла в голову гениальная мысль переделать все наши работы на С++. Времени до завтра, так что помогите пожалуйста сколько сможете) ВОт сбственно задачи: 5)Вычислить среднее арифметическое положи< тельных Srp3 и отрицательных Sro3 элементов третьего столбца матрицы {aij}, где i = j = 1, ..., 5. Заранее спасибо. Верю надеюсь и жду.
C++ Заполнить массив случайными числами ,подсчитать в этом массиве среднее арифметическое всех элементов Весь семестр программировали на Бейсике и вдруг преподу пришла в голову гениальная мысль переделать все наши работы на С++. Времени до завтра, так что помогите пожалуйста сколько сможете) ВОт сбственно задачи: 4)Создать массив a1, a2, ..., an из n случайных чисел в пределах от 0 до 100. Подсчитать в этом массиве среднее арифметическое всех элементов, найти макси мальный max и минимальный... подробнее

Показать сообщение отдельно
SeryZone
 Аватар для SeryZone
56 / 28 / 5
Регистрация: 09.03.2012
Сообщений: 726
Записей в блоге: 1
20.12.2012, 22:24     Нужно разобрать код!
Я хочу построить фрактал Мандельброта и увеличить его. Но я могу это сделать не более чем в 1015-ю степень(тип long double). Поэтому я хочу реализовать высокоточную арифметику. Я рыл программы, интернет и нашёл то, что искал. Но я плохо понимаю С++(я обычно прогаю на Делфи, но и С++ понемногу изучаю) и не могу понять код! Помогите! Что за что отвечает?
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
355
356
#ifndef HIGH_PREC_MATH_H
#define HIGH_PREC_MATH_H
 
// This class stores high precision numbers with runtime variable precision,
// up to a fixed length. The number of bits to the left of the decimal
// point is compile-time fixed. This class provides some basic
// mathematical operations. Note that when doing math on a pair of
// numbers they must both have the same precision.
// Note that in most case this class can be used with signed or unsigned
// numbers -- because the numbers are twos complement there is
// usually no difference. However initialization and operator< and
// a few other functions do interpret the numbers as
// being signed numbers, with the most significant bit being the
// sign bit.
 
#ifdef  _DEBUG
// OVERRUN_CHECKING checks for overruns in the high-precision math class.
// It should generally only be enabled in debug builds or when investigating
// memory corruption because it has a performance cost.
#define OVERRUN_CHECKING
#endif
 
class HighPrecMath
{
public:
    // Standard Fractal eXtreme numbers have 3+kShiftPerElement bits
    // (3 bits plus one entire element) to the left of the decimal point.
    // However there is no reason why a high-precision plugin can't use
    // a different format with a different number of bits to the left
    // of the decimal point, or even a variable number -- high-precision
    // floating-point math.
    // Three bits to the left of the decimal point is *just* barely enough
    // for the Mandelbrot set with an overflow point of 4.0 (2.0 squared).
    // It takes careful detection of overflow to make it work, and the
    // math becomes much simpler if we waste a few bits of precision and
    // have 5 bits to the left of the decimal point. All we have to do is
    // shift the number down a few bits when initializing, and adjust appropriately
    // when multiplying. The binary point position could be set to a larger
    // value, but even more precision would be lost. Setting it to values smaller
    // than 5 is untested and would require careful analysis.
    static const int kIntegerBits = 5;
#ifdef OVERRUN_CHECKING
    static const FixedElementS padData = -1234567890;
#endif
    // Construct a HighPrecMath object from little-endian twos-complement
    // numbers in the 3.n format.
    HighPrecMath(const FixedElement* pData, int totalNumElements)
    {
        InitPadding();
#ifdef  _M_X64
        // The minimum precision supported by the 64-bit math functions in
        // FXMathHelper.dll is two elements, or 128 bits. Other math
        // support functions may have other limitations.
        assert(totalNumElements >= 2 && totalNumElements < _countof(m_data));
#else
        // The minimum precision supported by the 32-bit math functions in
        // FXMathHelper.dll is three elements, or 96 bits. Other math
        // support functions may have other limitations.
        assert(totalNumElements >= 3 && totalNumElements < _countof(m_data));
#endif
        // It is unlikely, but theoretically possible, that FX could send
        // numbers more precise than kMaxFixedElements. If FX requests more
        // precision than we can handle then just lop off the least
        // significant data and clamp totalNumElements.
        if (totalNumElements > _countof(m_data))
        {
            pData += (totalNumElements - _countof(m_data));
            totalNumElements = _countof(m_data);
        }
        // Copy the input data.
        memcpy(m_data, pData, totalNumElements * sizeof(m_data[0]));
        assert(totalNumElements >= 2 && totalNumElements < _countof(m_data));
        m_precision = totalNumElements;
 
        CheckPadding();
 
        // Shift over enough to adjust for the change from 3.n format to
        // kIntegerBits.n format.
        FixedShiftRight(m_data, kIntegerBits - 3, m_precision);
        CheckPadding();
    }
 
    // The built-in copy constructor works fine, but copies too much data. By
    // writing our own copy constructor we can copy only the live data, which
    // makes for a significant speedup.
    HighPrecMath(const HighPrecMath& rhs)
    {
        m_precision = rhs.m_precision;
        memcpy(m_data, rhs.m_data, m_precision * sizeof(m_data[0]));
#ifdef OVERRUN_CHECKING
        memcpy(m_prePadding, rhs.m_prePadding, sizeof(m_prePadding));
        memcpy(m_postPadding, rhs.m_postPadding, sizeof(m_postPadding));
#endif
    }
 
    // The built-in assignment operator works fine, but copies too much data. By
    // writing our own assignment operator we can copy only the live data, which
    // makes for a significant speedup.
    HighPrecMath& operator=(const HighPrecMath& rhs)
    {
        m_precision = rhs.m_precision;
        memcpy(m_data, rhs.m_data, m_precision * sizeof(m_data[0]));
#ifdef OVERRUN_CHECKING
        memcpy(m_prePadding, rhs.m_prePadding, sizeof(m_prePadding));
        memcpy(m_postPadding, rhs.m_postPadding, sizeof(m_postPadding));
#endif
        return *this;
    }
 
    // Do an unsigned comparison against an overflow amount. Doing an unsigned
    // comparison buys one extra bit of precision and is safe because we only
    // call this against the sum of two squares.
    bool Overflow() const
    {
        CheckPadding();
        return m_data[m_precision-1] > FixedElement(4) << (kShiftPerElement - kIntegerBits);
    }
 
    bool IsNegative() const
    {
        CheckPadding();
        // Grab the most-significant element, cast it to a signed type,
        // and check to see whether it is negative.
        return FixedElementS(m_data[m_precision-1]) < 0;
    }
 
    // Multiply in place. This is the most efficient way to multiply.
    // This function properly handles the case where this == &rhs.
    HighPrecMath& operator*=(const HighPrecMath& rhs)
    {
        assert(m_precision == rhs.m_precision);
        CheckPadding();
 
        // Note that the FixedMultiply routine checks to see
        // whether m_data and rhs.m_data are the same, and if
        // so uses a special squaring routine which is optimized
        // for this case.
        // Used properly this can give significant speedups on many
        // fractal formulae.
 
        FixedMultiplyS(m_data, rhs.m_data, m_precision);
        CheckPadding();
 
        // Because both numbers are assumed to be in kIntegerBits.n format the
        // result of calling FixedMultiply is a number in
        // kIntegerBits+kIntegerBits.n format. For instance, multiplying two
        // 5.n numbers together gives us a 10.n result, with a loss of five
        // bits of fractional precision.
        // In order to get it back into kIntegerBits.n format we need to shift
        // it left by kIntegerBits or multiply it by 1<<kIntegerBits. Only routines that
        // multiply or divide to fixed-point numbers have to deal with
        // this. Note that while the multiply of two high precision
        // numbers cannot overflow, this shift can.
        // See the sampleplugin's readme.txt for more details.
        *this <<= kIntegerBits;
 
        CheckPadding();
        return *this;
    }
 
    // Multiply in place by an integer. This is the most efficient way to multiply.
    HighPrecMath& operator*=(int rhs)
    {
        // Warning: this can overflow.
        FixedMultiply(m_data, rhs, m_precision);
        CheckPadding();
        return *this;
    }
 
    // Shift left by the specified number of places -- this is equivalent to
    // multiplying by 2^shiftAmount.
    HighPrecMath& operator<<=(int shiftAmount)
    {
        // Warning: this can overflow.
        assert(shiftAmount < kShiftPerElement);
        FixedShiftLeft(m_data, shiftAmount, m_precision);
        return *this;
    }
 
    // Add in place. This is the most efficient way to add.
    // This function properly handles the case where this == &rhs.
    HighPrecMath& operator+=(const HighPrecMath& rhs)
    {
        assert(m_precision == rhs.m_precision);
        FixedAdd(m_data, rhs.m_data, m_precision);
        CheckPadding();
        return *this;
    }
 
    // Subtract in place. This is the most efficient way to subtract.
    // This function properly handles the case where this == &rhs.
    HighPrecMath& operator-=(const HighPrecMath& rhs)
    {
        assert(m_precision == rhs.m_precision);
        FixedSubtract(m_data, rhs.m_data, m_precision);
        CheckPadding();
        return *this;
    }
 
    // Note that this does a signed comparison.
    bool operator<(const HighPrecMath& rhs)
    {
        assert(m_precision == rhs.m_precision);
        CheckPadding();
        return FixedLessThanSigned(m_data, rhs.m_data, m_precision);
    }
 
    void InitPadding()
    {
#ifdef OVERRUN_CHECKING
        for (int i = 0; i < _countof(m_prePadding); ++i)
            m_prePadding[i] = padData;
        for (int i = 0; i < _countof(m_postPadding); ++i)
            m_postPadding[i] = padData;
#endif
    }
    void CheckPadding() const
    {
#ifdef OVERRUN_CHECKING
        for (int i = 0; i < _countof(m_prePadding); ++i)
            if (m_prePadding[i] != padData)
                __debugbreak();
        for (int i = 0; i < _countof(m_postPadding); ++i)
            if (m_postPadding[i] != padData)
                __debugbreak();
#endif
    }
 
private:
#ifdef OVERRUN_CHECKING
    // Put in a few padding elements to watch for
    // overwrites at either end of the data array.
    FixedElement m_prePadding[10];
#endif
    FixedElement m_data[kMaxFixedElements];
#ifdef OVERRUN_CHECKING
    FixedElement m_postPadding[2];
#endif
    int m_precision;
};
 
inline HighPrecMath operator*(const HighPrecMath& lhs, const HighPrecMath& rhs)
{
    HighPrecMath result(lhs);
    // Check for squaring. If we are doing squaring (if &lhs == &rhs)
    // then we multiply result by itself so that downstream functions can
    // detect that squaring is being done and use faster routines.
    if (&lhs == &rhs)
        result *= result;
    else
        result *= rhs;
    return result;
}
 
inline HighPrecMath operator*(const HighPrecMath& lhs, int rhs)
{
    HighPrecMath result(lhs);
    result *= rhs;
    return result;
}
 
inline HighPrecMath operator<<(const HighPrecMath& lhs, int shiftAmount)
{
    HighPrecMath result(lhs);
    result <<= shiftAmount;
    return result;
}
 
inline HighPrecMath operator+(const HighPrecMath& lhs, const HighPrecMath& rhs)
{
    HighPrecMath result(lhs);
    result += rhs;
    return result;
}
 
inline HighPrecMath operator-(const HighPrecMath& lhs, const HighPrecMath& rhs)
{
    HighPrecMath result(lhs);
    result -= rhs;
    return result;
}
 
// This function converts from fixed-point format to double
// precision. Obviously this loses precision but it can be very convenient
// when experimenting, and it serves as executable documentation for
// the fixed-point format. The default format for the input fixed-point
// number is Fractal eXtreme's 35.n or 67.n format.
inline double DoubleFromFixed(const FixedElement* pData, int totalNumElements, int bitsToLeft = kBinaryPoint + kShiftPerElement)
{
    FixedElement localCopy[kMaxFixedElements];
 
    // It is unlikely, but theoretically possible, that FX could send
    // numbers more precise than kMaxFixedElements. If FX requests more
    // precision than we can handle then just lop off the least
    // significant elements and clamp totalNumElements.
    if (totalNumElements > _countof(localCopy))
    {
        pData += (totalNumElements -  _countof(localCopy));
        totalNumElements =  _countof(localCopy);
    }
    // Copy the input data to a local array so that we can modify it
    // to make it guaranteed positive -- modifying the data that was
    // passed to us is not allowed.
    memcpy(localCopy, pData, totalNumElements * sizeof(localCopy[0]));
    // Grab the most-significant element, which contains the
    // sign bit.
    FixedElementS signElement = localCopy[totalNumElements-1];
    bool positive = true;
    if (signElement < 0)
    {
        // Converting from fixed-point to double is much easier if we
        // are dealing with an unsigned number, so we convert our number
        // from twos-complement to unsigned in this block of code.
        positive = false;
        // Negating a twos-complement number is done by XORing all elements
        // and then adding one to the last significant bit, with carry
        // as needed.
        bool carry = true;
        for (int i = 0; i < totalNumElements; ++i)
        {
            localCopy[i] = ~localCopy[i];
            if (carry)
            {
                localCopy[i] += 1;
                // If adding one caused the value to wrap around to zero
                // then that means we have a carry which we must propagate
                // to the next element. Otherwise we are done with carrying
                // bits.
                carry = (localCopy[i] == 0);
            }
        }
    }
 
    // Now scan through the array accumulating the values into a double,
    // with an appropriate scale factor.
    double result = 0.0;
 
    for (int i = 0; i < totalNumElements; ++i)
    {
        // The pow expression gets the apropriate multiplier for each
        // element. If we had no bits to the left of the decimal point
        // (an entirely fractional number) then the last exponent for
        // pow should be -kShiftPerElement, so we calculate that and
        // then add bitsToLeft to it. For previous elements the exponent
        // should be successively kShiftPerElement items lower.
        int exponent = (i - totalNumElements) * kShiftPerElement + bitsToLeft;
        double value = localCopy[i] * pow(2.0, exponent);
        result += value;
    }
 
    if (!positive)
        result = -result;
    return result;
}
 
#endif
Полный проект можно скачать здесь(код взят из highprecmath.h): ftp://ftp.cygnus-software.com/pub/pluginkit.zip
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 01:26. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru