visual studio 200X многопоточность С#

[gdoom]

Ткнулся ради интереса в саму библиотеку System::Math:: (тут как в с++ всё же он родней мне )
вот что испробовал:

Используется синтаксис C#

            // расчёт exp(x)
            { 
            System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
            swatch.Start(); // старт
            double z;
            z = 5.0;
            z = System.Math.Exp(z);
            swatch.Stop(); // стоп
            textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
            // раскладываем в ряд
            {
                System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
                swatch.Start(); // старт
                double z;
                z = 5.0;
                z = 1+z+z*z/2+z*z*z/6+z*z*z*z/24+z*z*z*z*z/120 + z*z*z*z*z*z / 720 + z*z*z*z*z*z*z/5040+z*z*z*z*z*z*z*z/40320+ z * z * z * z * z * z * z * z*z/362880;
                swatch.Stop(); // стоп
                textBox1.Text = textBox1.Text + "dz = " + System.Convert.ToString(z-System.Math.Exp(5)) + "\r\n";
                textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
 

00:00:00.0000076
dz = -4.72370253291172
00:00:00.0000007

- вот что для exp(x), 0.0000076 сек - для родной библиотеки(Math) и сам разложил в ряд Тейлора до n=9
- dz = -4.72370253291172 погрешность между разложением моим и библиотекой(Math)
- для разложения 0.0000007 сек для n=9 при этом x = 5.0;
итого в 10,8571 раза быстрей, думаю, что в самой тут фишка в точности т.к сама среда берёт точность до размерности хранимого типа данных, а именно до double.....
логично, что для всех других стандартных функций такая же история....
думаю в этой стороне посмотрю, пока что - и посмотрим на сколько выйдет увеличить скорость расчёта - но уже что то выпало)

[gdoom]

Используется синтаксис C#

 // расчёт логарифма
            {
                System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
                swatch.Start(); // старт
                double z;
                z = 5.0;
                z = System.Math.Log(z);
                swatch.Stop(); // стоп
                textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
            // раскладываем в ряд
            {
                System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
                swatch.Start(); // старт
                double z;
                z = 5.0;
                z = (z - 1.0) / (z + 1.0);
                z = 2.0 * z * (1.0+1.0/3*z*z+1.0/5*z*z*z*z+1.0/7*z*z*z*z*z*z+1.0/9*z*z*z*z*z*z*z*z+1.0/11*z*z*z*z*z*z*z*z*z*z+1.0/13*z*z*z*z*z*z*z*z*z*z*z*z);               
                swatch.Stop(); // стоп
                textBox1.Text = textBox1.Text + "dz = " + System.Convert.ToString(z - System.Math.Log(5.0)) + "\r\n";
                textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
 

то же самое по логарифму с основанием "e" ну вы поняли)

00:00:00.0000069
dz = -0.000503617533912815
00:00:00.0000007

с отклонением в 0.000503617533912815 для x = 5.0, выходит прирост скорости в 4.9286 раза.

[arseniiv]

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]

О боги.
1. Вы неправильно измеряете время. Как минимум надо объединить много однотипных повторений интересующего куска в цикле, чтобы уменьшить влияние хоть части шума. Но и это всё равно сгодится только как первое приближение.
2. Не нужно создавать два Stopwatch, хватит и одного.
3. В общем случае для разных значений два способа вычислить одну и ту же числовую функцию могут расходиться друг с другом и относительно точного значения как угодно. По значениям в лишь одном аргументе делать выводы не стоит.
4. Вычисления делает не среда CLR, а скомпилированные из промежуточного языка инструкции для FPU. Методы Math — просто обёртки. (Ну, должно быть так. MS открыли недавно код, и стоит поглядеть, что там…) А уж FPU работает внутри себя с числами разрядности даже больше чем у double. После вычислений они округляются до double/float по надобности.
5. Даже если по результатам измерений и выйдет гарантированное ускорение у менее точно вычисляющего кода, эта погрешность может сказаться на результатах неожиданно сильно. Или ожиданно, но в это не верится. Вы даже так и не сказали, зачем вам такая куча экспонент. А то вдруг надо вычислить, скажем, $e^a, e^{2a},\ldots, e^{na}$ — тут можно делать гораздо меньше $n$ вызовов exp при сохранении неплохой точности.
6. В любом случае голоса в голове говорят «профайлер, профайлер». Я им не пользовался, но все утверждают, что перед оптимизацией скорости стоит сначала узнать, что именно больше всего тормозит — ах, эти странные люди!
7. Используйте String.Format (а когда сложений строк ещё больше, то StringBuilder). Как минимум выглядит яснее:

Используется синтаксис C#

// было
textBox1.Text = textBox1.Text + "dz = " + System.Convert.ToString(z - System.Math.Log(5.0)) + "\r\n";
textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";

// стало
// + в самом начале файла 'using System;', если нету
textBox1.Text += string.Format("dz = {0}\n{1}\n", z - Math.Log(5.0), swatch.Elapsed);

Сейчас вам ещё поквалифицированнее напишут, но столько ляпов в одном месте — надо как-то повнимательнее, что ли…

[gdoom]

arseniiv в сообщении #1069507 писал(а):

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]

О боги.
1. Вы неправильно измеряете время. Как минимум надо объединить много однотипных повторений интересующего куска в цикле, чтобы уменьшить влияние хоть части шума. Но и это всё равно сгодится только как первое приближение.
2. Не нужно создавать два Stopwatch, хватит и одного.
3. В общем случае для разных значений два способа вычислить одну и ту же числовую функцию могут расходиться друг с другом и относительно точного значения как угодно. По значениям в лишь одном аргументе делать выводы не стоит.
4. Вычисления делает не среда CLR, а скомпилированные из промежуточного языка инструкции для FPU. Методы Math — просто обёртки. (Ну, должно быть так. MS открыли недавно код, и стоит поглядеть, что там…) А уж FPU работает внутри себя с числами разрядности даже больше чем у double. После вычислений они округляются до double/float по надобности.
5. Даже если по результатам измерений и выйдет гарантированное ускорение у менее точно вычисляющего кода, эта погрешность может сказаться на результатах неожиданно сильно. Или ожиданно, но в это не верится. Вы даже так и не сказали, зачем вам такая куча экспонент. А то вдруг надо вычислить, скажем, $e^a, e^{2a},\ldots, e^{na}$ — тут можно делать гораздо меньше $n$ вызовов exp при сохранении неплохой точности.
6. В любом случае голоса в голове говорят «профайлер, профайлер». Я им не пользовался, но все утверждают, что перед оптимизацией скорости стоит сначала узнать, что именно больше всего тормозит — ах, эти странные люди!
7. Используйте String.Format (а когда сложений строк ещё больше, то StringBuilder). Как минимум выглядит яснее:

Используется синтаксис C#

// было
textBox1.Text = textBox1.Text + "dz = " + System.Convert.ToString(z - System.Math.Log(5.0)) + "\r\n";
textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";

// стало
// + в самом начале файла 'using System;', если нету
textBox1.Text += string.Format("dz = {0}\n{1}\n", z - Math.Log(5.0), swatch.Elapsed);

Сейчас вам ещё поквалифицированнее напишут, но столько ляпов в одном месте — надо как-то повнимательнее, что ли…

- да я понимаю Вас вы же понимаете, что я специально вывел два сегмента в отдельные части.
- ну про строчку:

Используется синтаксис C#

// стало
// + в самом начале файла 'using System;', если нету
textBox1.Text += string.Format("dz = {0}\n{1}\n", z - Math.Log(5.0), swatch.Elapsed);

это понятно, она вынесена за пределы stop_time - так что форма неважна, ну да согласен с Вами - грамотность программная
- ну по поводу измерения, да согласен - очень трудно - т.к запустил, что то левое и получил другое время; поэтому расчёт идёт сразу друг за другом два модуля;

-- Пн ноя 02, 2015 15:39:23 --

Используется синтаксис C#

            // ----------------------------------------------
            // - ------ тестовый расчёт ---------------------
            {
                System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
                swatch.Start(); // старт
                double p1, p2, p3, p4, p5, p6, p7;
                p1 = 10.0;
                p2 = 8.0;
                p3 = 7.0;
                p4 = 6.0;
                p5 = 5.0;
                p6 = 4.0;
                p7 = 3.0;
                double q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13;
                int z;
                double R;
                double T;
                T = 500.0;
                R = 478.0;
                z = 15;
                q1 = System.Math.Sqrt((p1 * p1 - p2 * p2) / (z * R * T));
                q2 = System.Math.Sqrt((p2 * p2 - p3 * p3) / (z * R * T));
                q3 = System.Math.Sqrt((p3 * p3 - p4 * p4) / (z * R * T));
                q4 = System.Math.Sqrt((p4 * p4 - p5 * p5) / (z * R * T));
                q5 = System.Math.Sqrt((p5 * p5 - p6 * p6) / (z * R * T));
                q6 = System.Math.Sqrt((p6 * p6 - p7 * p7) / (z * R * T));
                q7 = System.Math.Sqrt((p1 * p1 - p3 * p3) / (z * R * T));
                q8 = System.Math.Sqrt((p1 * p1 - p4 * p4) / (z * R * T));
                q9 = System.Math.Sqrt((p1 * p1 - p5 * p5) / (z * R * T));
                q10 = System.Math.Sqrt((p1 * p1 - p6 * p6) / (z * R * T));
                double ro;
                ro = p1 / R / T;
                q11 = ro*System.Math.Exp((1/1.8)*System.Math.Log(p2/p1))*System.Math.Sqrt(2*1.8/(0.8)*p1/ro*(1-System.Math.Exp((0.8/1.8)*System.Math.Log(p2/p1))));
                q12 = ro * System.Math.Exp((1 / 1.8) * System.Math.Log(p3 / p1)) * System.Math.Sqrt(2 * 1.8 / (0.8) * p1 / ro * (1 - System.Math.Exp((0.8 / 1.8) * System.Math.Log(p3 / p1))));
                q13 = ro * System.Math.Exp((1 / 1.8) * System.Math.Log(p4 / p1)) * System.Math.Sqrt(2 * 1.8 / (0.8) * p1 / ro * (1 - System.Math.Exp((0.8 / 1.8) * System.Math.Log(p4 / p1))));
                swatch.Stop(); // стоп
                textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
            // ----------------------------------------------
            // ------ теперь через разложения ---------------
            {
                System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch();// создаем объект
                swatch.Start(); // старт
                double p1, p2, p3, p4, p5, p6, p7;
                p1 = 10.0;
                p2 = 8.0;
                p3 = 7.0;
                p4 = 6.0;
                p5 = 5.0;
                p6 = 4.0;
                p7 = 3.0;
                double q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13;
                int z;
                double R;
                double T;
                T = 500.0;
                R = 478.0;
                z = 15;
                double ro;
                ro = p1 / R / T;
                double x, y;
                x = 0.0;
                y = 0.0;
                //q1 = System.Math.Sqrt((p1 * p1 - p2 * p2) / (z * R * T));
                x = (p1 * p1 - p2 * p2) / z / R / T;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.5 * x;
                q1 = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                
                //q2 = System.Math.Sqrt((p2 * p2 - p3 * p3) / (z * R * T));
                x = (p2 * p2 - p3 * p3) / z / R / T;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);

                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                //q8 = System.Math.Sqrt((p1 * p1 - p4 * p4) / (z * R * T));
                x = (p1 * p1 - p4 * p4) / z / R / T;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.5 * x;
                q8 = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                //q9 = System.Math.Sqrt((p1 * p1 - p5 * p5) / (z * R * T));
                x = (p1 * p1 - p5 * p5) / z / R / T;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.5 * x;
                q9 = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                //q10 = System.Math.Sqrt((p1 * p1 - p6 * p6) / (z * R * T));
                x = (p1 * p1 - p6 * p6) / z / R / T;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.5 * x;
                q10 = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                //q11 = ro * System.Math.Exp((1 / 1.8) * System.Math.Log(p2 / p1)) * System.Math.Sqrt(2 * 1.8 / (0.8) * p1 / ro * (1 - System.Math.Exp((0.8 / 1.8) * System.Math.Log(p2 / p1))));
                x = p2/p1*1.0;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8/1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = p1 / ro * 1.0*2*1.8/0.8;
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8 / 1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = x * ro;
                y = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                y = y * 1 / 1.8;
                y = 1.0 + y + y * y / 2.0 + y * y * y / 6.0 + y * y * y * y / 24.0 +
                    y * y * y * y * y / 120.0 + y * y * y * y * y * y / 720.0 +
                    y * y * y * y * y * y * y / 5040.0 + y * y * y * y * y * y * y * y / 40320.0 +
                    y * y * y * y * y * y * y * y * y / 362880.0 + y * y * y * y * y * y * y * y * y * y / 3628800.0;
                q11 = x * y * 1.0;
                //q12 = ro * System.Math.Exp((1 / 1.8) * System.Math.Log(p3 / p1)) * System.Math.Sqrt(2 * 1.8 / (0.8) * p1 / ro * (1 - System.Math.Exp((0.8 / 1.8) * System.Math.Log(p3 / p1))));
                x = p3 / p1 * 1.0;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8 / 1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = p1 / ro * 1.0 * 2 * 1.8 / 0.8;
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8 / 1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = x * ro;
                y = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                y = y * 1 / 1.8;
                y = 1.0 + y + y * y / 2.0 + y * y * y / 6.0 + y * y * y * y / 24.0 +
                    y * y * y * y * y / 120.0 + y * y * y * y * y * y / 720.0 +
                    y * y * y * y * y * y * y / 5040.0 + y * y * y * y * y * y * y * y / 40320.0 +
                    y * y * y * y * y * y * y * y * y / 362880.0 + y * y * y * y * y * y * y * y * y * y / 3628800.0;
                q12 = x * y * 1.0;
                //q13 = ro * System.Math.Exp((1 / 1.8) * System.Math.Log(p4 / p1)) * System.Math.Sqrt(2 * 1.8 / (0.8) * p1 / ro * (1 - System.Math.Exp((0.8 / 1.8) * System.Math.Log(p4 / p1))));
                x = p4 / p1 * 1.0;
                y = (x - 1.0) / (x + 1.0);
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8 / 1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = p1 / ro * 1.0 * 2 * 1.8 / 0.8;
                x = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                x = 0.8 / 1.8 * x;
                x = 1.0 + x + x * x / 2.0 + x * x * x / 6.0 + x * x * x * x / 24.0 +
                    x * x * x * x * x / 120.0 + x * x * x * x * x * x / 720.0 +
                    x * x * x * x * x * x * x / 5040.0 + x * x * x * x * x * x * x * x / 40320.0 +
                    x * x * x * x * x * x * x * x * x / 362880.0 + x * x * x * x * x * x * x * x * x * x / 3628800.0;
                x = x * ro;
                y = 2 * y * (1 + 1 / 3.0 * y * y + 1 / 5.0 * y * y * y * y + 1 / 7.0 * y * y * y * y * y * y + 1 / 9.0 * y * y * y * y * y * y * y * y + 1 / 11.0 * y * y * y * y * y * y * y * y * y * y
                    + 1 / 13.0 * y * y * y * y * y * y * y * y * y * y * y * y + 1 / 15.0 * y * y * y * y * y * y * y * y * y * y * y * y * y * y);
                y = y * 1 / 1.8;
                y = 1.0 + y + y * y / 2.0 + y * y * y / 6.0 + y * y * y * y / 24.0 +
                    y * y * y * y * y / 120.0 + y * y * y * y * y * y / 720.0 +
                    y * y * y * y * y * y * y / 5040.0 + y * y * y * y * y * y * y * y / 40320.0 +
                    y * y * y * y * y * y * y * y * y / 362880.0 + y * y * y * y * y * y * y * y * y * y / 3628800.0;
                q13 = x * y * 1.0;

                swatch.Stop(); // стоп
                textBox1.Text = textBox1.Text + System.Convert.ToString(swatch.Elapsed) + "\r\n";
            }
            // ----------------------------------------------
 

- короче половину выпилил, по времени пошло плоховато: 40% спасает по скорости.... по поводу погрешности 10 степень разложения, обеспечивает требуемую погрешность в 0,1-0,3%

[Dmitriy40]

Ну и при разложении неплохо бы использовать что-то аналогичное "схеме Горнера" (вычисление следующей производной из предыдущей, а не с самого начала), хотя это может и компилятор соптимизировать ...
В качестве dz выводите относительную погрешность, а не абсолютную, последняя собственно почти ни о чём не говорит.
И не забудьте что double даёт точность практически 16 знаков, т.е. относительную погрешность около $10^{-16}$. Ну или хоть float с его точностью 7 знаков (или $10^{-7}$). Вот когда получите близкую точность с разложением в ряд - тогда и сравнивайте скорости. А то точность логарифма в 0.03% и экспоненты в 3% (!!) ну совершенно не впечатляет, несмотря даже на скорость.
Для точности в 3% достаточно таблички из сотни значений, которая "вычисляться" будет ещё во много раз быстрее.
Ну и как правильно указали, замеряйте время вычислений хотя бы сотни миллионов итераций (чтобы общее время составило десятки секунд и более).

[gdoom]

arseniiv в сообщении #1069507 писал(а):

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]
1. Вы неправильно измеряете время. Как минимум надо объединить много однотипных повторений интересующего куска в цикле, чтобы уменьшить влияние хоть части шума. Но и это всё равно сгодится только как первое приближение.

- тут я ответил ранним Вам постом....

arseniiv в сообщении #1069507 писал(а):

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]
Не нужно создавать два Stopwatch, хватит и одного.

ну да согласен - просто тут я скоро пихну их в потоки для определения времени расчёта, так заготовка..

arseniiv в сообщении #1069507 писал(а):

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]
4. Вычисления делает не среда CLR, а скомпилированные из промежуточного языка инструкции для FPU. Методы Math — просто обёртки. (Ну, должно быть так. MS открыли недавно код, и стоит поглядеть, что там…) А уж FPU работает внутри себя с числами разрядности даже больше чем у double. После вычислений они округляются до double/float по надобности.

- посмотрел и был удивлён - действительно скажем так в этой библиотеке они болт ложили на скорость

arseniiv в сообщении #1069507 писал(а):

[В ответ на экспоненту, хотя к коду для логарифма это тоже относится.]
В любом случае голоса в голове говорят «профайлер, профайлер». Я им не пользовался, но все утверждают, что перед оптимизацией скорости стоит сначала узнать, что именно больше всего тормозит — ах, эти странные люди!

и тут вы правы, как раз две операции Ln(x) Exp(x) а именно

Exp(()*Ln())

- думаю понятно, что тут можно вертеть степень.... вот тут съедается удивительно много времени, а как думаете почему?
- как я понял из описания, т.к юзают товарищи приближённые методы - а именно через аппроксимацию находят, пока погрешность не станет 0,000000- и т.д = ) а уровень думаете какой, если по pi считать то 3.14159265358979323846

[Dmitriy40]

gdoom в сообщении #1069536 писал(а):

обеспечивает требуемую погрешность в 0,1-0,3%

Кошмар, для получения такой точности достаточно операций с целыми числами 16 битов длиной (или даже меньше), точнее дробными, но размером 16 бит в сумме, все функции сделайте табличными, ну и компилятору разрешить (и заставить) использовать SSE/AVX (т.к. много параллельных операций).

[rockclimber]

gdoom в сообщении #1069541 писал(а):

- посмотрел и был удивлён - действительно скажем так в этой библиотеке они болт ложили на скорость

Код покажите, как вы это меряли, а то есть у меня подозрение одно...

[arseniiv]

gdoom в сообщении #1069541 писал(а):

и тут вы правы, как раз две операции Ln(x) Exp(x)

Как раз-таки много всяких операций, в том числе в полном коде (про который, в основном, и речь: вы сейчас пытаетесь оптимизировать что-то ещё и в пику точности, когда, возможно, есть оптимизация другого, и без таких жертв) ещё и возня с потоками.

Вы так и не сказали, зачем такая куча экспонент. Логика подсказывает, что именно её надо попытаться оптимизировать в первую очередь.

-- Пн ноя 02, 2015 19:16:48 --

arseniiv в сообщении #1069507 писал(а):

MS открыли недавно код, и стоит поглядеть, что там…

(Для заинтересованных.) Ага, там все интересные методы у Math помечены как автогенерируемые: http://referencesource.microsoft.com/#mscorlib/system/math.cs. Может быть, они инлайниться даже могут благодаря этому…

[gdoom]

Dmitriy40 в сообщении #1069543 писал(а):

gdoom в сообщении #1069536 писал(а):

обеспечивает требуемую погрешность в 0,1-0,3%

Кошмар, для получения такой точности достаточно операций с целыми числами 16 битов длиной (или даже меньше), точнее дробными, но размером 16 бит в сумме, все функции сделайте табличными, ну и компилятору разрешить (и заставить) использовать SSE/AVX (т.к. много параллельных операций).

- а вот это вариант, попробую, спасибо большое)

rockclimber в сообщении #1069544 писал(а):

gdoom в сообщении #1069541 писал(а):

- посмотрел и был удивлён - действительно скажем так в этой библиотеке они болт ложили на скорость

Код покажите, как вы это меряли, а то есть у меня подозрение одно...

код выше валяется, хотя тут я не согласен с методом оценки времени - конечно, для меня проще замеры - как для микроконтрольщика есть код на asm - е где я могу посмотреть количество тактов и умножить на время выполнения такта)

arseniiv в сообщении #1069507 писал(а):

MS открыли недавно код, и стоит поглядеть, что там…

(Для заинтересованных.) Ага, там все интересные методы у Math помечены как автогенерируемые: http://referencesource.microsoft.com/#mscorlib/system/math.cs. Может быть, они инлайниться даже могут благодаря этому…[/quote]
- не увидел к сожалению вставок, может ткнёте меня непосредственно в кусок кода пожалуйста
а вот как я вижу алгоритм быстрый http://www.azillionmonkeys.com/qed/sqroot.html

-- Вт ноя 03, 2015 07:30:11 --

По поводу вопроса, что за задача - уравнения, что применяются - это уравнения расхода через лабиринтное уплотнение, вот немного пояснение http://www.findpatent.ru/patent/238/2382893.html - в ГТД двигателе такими уплотнениями регулируются система охлаждения внутренних узлов двигателя, а так же регулируется равномерно распределения усилия на узлы ротора. Их расчёт очень большая проблема на сегодня и как только не извращаются, для вычисления - в советское время просто заменяли на аналог электрической цепи. Система течения - это гидравлическая схема(только вот там сжимаемая среда). Участки регулировки представляют из себя - систему дроссель участков, трубок и отверстий.
http://uploads.ru/0c4ld.png

-- Вт ноя 03, 2015 07:34:25 --

на картинке слева - идёт камера сгорания, потом сопловой аппарат, после идёт 3ступени турбины. Стрелками отмечаются направления течения.

[aa_dav]

gdoom в сообщении #1069742 писал(а):

как для микроконтрольщика есть код на asm - е где я могу посмотреть количество тактов и умножить на время выполнения такта)

У меня для вас плохие новости - на современных процессорах уже десятки лет этот подход просто не работает.

Базовые азы современных реалий:
- Процессор - это сложная нелинейная система параллельных вычислителей, только притворяющаяся былой машиной состояний с линейными переходами от команды к команде. "скорость инструкции" замерить просто нельзя. Правдоподобно меряются только огромные (читай - очень огромные) блоки инструкций.
- Львиный вклад в производительность современного процессора осуществляет кеширование обмена данными с ОЗУ. Кеш. Это и проблема для правдоподобных замеров, потому что, к примеру, суммируя два огромных массива вы сразу же рискуете померять не скорость процессора, а скорость шины памяти, процессор будет просто простаивать ожидая ввода-вывода, т.к. суммировать он умеет параллельно с этими собственно пересылками, очень очень долгими в мерках процессорных тактов. Кроме того первая итерация цикла интенсивных вычислений "локальных" может исполнятся гораздо дольше последующих, т.к. в ней заполняется кеш. В общем с кешем надо быть тоже очень аккуратным. И в то же время очень важно иметь это ввиду так как переписывание кода в, как говорят, кеш-френдли форму может привести к десятикратным ростам производительности.
- Не забывать про многозадачность ОС, если в момент промера у вас кванты времени "удачно" улетели в другие процессы - получится тоже чушь.

[arseniiv]

gdoom в сообщении #1069742 писал(а):

не увидел к сожалению вставок, может ткнёте меня непосредственно в кусок кода пожалуйста

Я и говорю, определений в этом исходном коде нет. Надо в другом месте искать, в коде, компилирующемся не в IL, вероятно, написанном на C++. Лень смотреть, раскрыт он там у них или нет. Ничего кроме тривиальной обёртки над инструкцией FEXP там быть не может.

-- Вт ноя 03, 2015 12:43:19 --

(Оффтоп)

gdoom в сообщении #1069742 писал(а):

По поводу вопроса, что за задача - уравнения, что применяются - это уравнения расхода через лабиринтное уплотнение, вот немного пояснение http://www.findpatent.ru/patent/238/2382893.html
- в ГТД двигателе такими уплотнениями регулируются система охлаждения внутренних узлов двигателя, а так же регулируется равномерно распределения усилия на узлы ротора. Их расчёт очень большая проблема на сегодня и как только не извращаются, для вычисления - в советское время просто заменяли на аналог электрической цепи. Система течения - это гидравлическая схема(только вот там сжимаемая среда). Участки регулировки представляют из себя - систему дроссель участков, трубок и отверстий.
http://uploads.ru/0c4ld.png

Ну, если не хотите говорить, откуда именно экспоненты именно в таком количестве, как хотите. С самого начала это перевыводить вряд ли многие захотят.

[gdoom]

aa_dav в сообщении #1069743 писал(а):

gdoom в сообщении #1069742 писал(а):

как для микроконтрольщика есть код на asm - е где я могу посмотреть количество тактов и умножить на время выполнения такта)

У меня для вас плохие новости - на современных процессорах уже десятки лет этот подход просто не работает.

Базовые азы современных реалий:
- Процессор - это сложная нелинейная система параллельных вычислителей, только притворяющаяся былой машиной состояний с линейными переходами от команды к команде. "скорость инструкции" замерить просто нельзя. Правдоподобно меряются только огромные (читай - очень огромные) блоки инструкций.
- Львиный вклад в производительность современного процессора осуществляет кеширование обмена данными с ОЗУ. Кеш. Это и проблема для правдоподобных замеров, потому что, к примеру, суммируя два огромных массива вы сразу же рискуете померять не скорость процессора, а скорость шины памяти, процессор будет просто простаивать ожидая ввода-вывода, т.к. суммировать он умеет параллельно с этими собственно пересылками, очень очень долгими в мерках процессорных тактов. Кроме того первая итерация цикла интенсивных вычислений "локальных" может исполнятся гораздо дольше последующих, т.к. в ней заполняется кеш. В общем с кешем надо быть тоже очень аккуратным. И в то же время очень важно иметь это ввиду так как переписывание кода в, как говорят, кеш-френдли форму может привести к десятикратным ростам производительности.
- Не забывать про многозадачность ОС, если в момент промера у вас кванты времени "удачно" улетели в другие процессы - получится тоже чушь.

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

[gdoom]

Добрый день друзья, давно не выходил - много работы .
Ну как стало понятно по ходу разработки и изучению статей:
http://habrahabr.ru/post/111021/
а так же капания в алгоритмах, стало ясно что очень хорошо жрёт ресурс:
Log() - просто ужасно есть ресурсы, как видно после изучения http://maths-people.anu.edu.au/~brent/pd/RNC7t.pdf вот этой интересной публикации понятно стало, что Log в Math модуле находиться через дискретные приближения, т.к они решают проблемы в общем - то есть, аргумент функции логарифма может быть рациональным числом(понятно что >1) и принимать значения гораздо больше единицы. Вот тут и проблема, что для отрезков [1,10] разложение в ряд Тейлора канает, а вот потом всё медленней сходиться при этом очень. Дискретный метод хорош, тем что похож на метод ньютона - но там проблемы с схождением для больших величин, но сходиться n^2 быстрей для "x" до 9000000, а вот дальше опять проблемы. Для величин "x" от 9000 очень рулит Fast Algorithms for High-Precision Computation of Elementary Functions Richard P. Brent метод этих ребят . Так что с логарифмом получилось справиться, пока точных цифр не могу сказать - ещё пилю алгоритм.
Далее проще с функцией квадратного корня - там метод ньютона рулит до величин 9000000.0 за 14 итераций всё (10^-5) погрешность это пойдёт для моих вычислений. Ах да Log теперь считается за 6 итераций и при этом этого метода нет в Math модуле C#(я же говорил что болт положили они ) (32 стр - в брашуре, что указал).
И пока ещё не решил проблему с Exp - но опять же буду пилить из брашуры, что указал(обратите внимание на год 2006! - и на вики там ссылка на не ёж, работа при этом совсем свежая - как я понял).
Вот пока, что так получается. Соберу алгоритм уже скоро посмотрим сколько по производительности будет)

-- Ср ноя 11, 2015 14:50:57 --

Ах да по поводу вычислений ISO/IEC 9899:1999 согласно ему - требования по ошибке должны бить в размере формата исчисления то есть если double (15 знаков)так, что и тут накладные на вычисления - а модуль расчёта С# соответственно удовлетворяют требованиям ISO вот тут и ноги растут на их длительность)

[Xaositect]

Там в заметке упоминается, что автор пишет книгу по этой теме. Книга вышла в 2010, скачать ее можно тут: http://www.loria.fr/~zimmerma/mca/mca-cup-0.5.9.pdf