Язык программирования для математика

[cupuyc]

nestoklon в сообщении #419412 писал(а):

Без обид, но Ваш. Передавать оператор суммы -- это жесть.

Да, соглашусь. Учитывая, что мой опыт программирования на эрланге к тому времени был около недели - вполне ожидаемая ошибка. Вы С++ тоже неделю учили?

nestoklon в сообщении #419412 писал(а):

Чем больше маленьких функций, тем лучше, так что ли?

Тут Вы правильно заметили, это действительно лучше.

nestoklon в сообщении #419412 писал(а):

Ну, по мне так это читабельности не сильно помогает.

Я понял, что по Вышему означает "читабельность". В Вашем коде её переизбыток.

Вы лично мои слова восприняли. Лучше скажите зачем Вы всё это писали, убили столько времени? Задача-то пустяковая. Стоила ли она этих извращений?

nestoklon в сообщении #419412 писал(а):

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

Это говорит о языке. Он совершенно непригоден для этой задачи. Вы это очень хорошо продемонстрировали.

nestoklon в сообщении #419412 писал(а):

Метод парабол -- строчки с 32 по 42, из которых половина для читабельности и две указание распараллелить код. Вы их не нашли? А мне казалось, Вы хотели посмотреть, как на c++ "правильно" обращаться с функциями "в общем виде" на простом примере.

В том-то и дело. Полезного кода 3 строчки. Что делает остальной код? Совместимость алгоритма с языком программирования?

nestoklon в сообщении #419412 писал(а):

А, Вы даже не просмотрели код. Ну тогда о чём мы говорим?

Я посмотрел, но, возможно, не увидел. Я и сейчас не вижу. Зачем Вы всё в одну строчку пишите? Думаете код короче сделать? Вообще если использовать лямбда-функции, то код получится такой же как на шарпе. Тогда для меня вообще загадка - что делает весь Ваш код.

[Maslov]

(Поправил немного код)

Поправил код в post418741.html#p418741:
Вместо

        forFnc(1, steps + 1, i => { lock (monitor) { result += 4 * fnc(xmin + (i-0.5)*dx); } });
        forFnc(1, steps,     i => { lock (monitor) { result += 2 * fnc(xmin + i*dx); } });

теперь

        forFnc(1, steps + 1, i => { double s = 4 * fnc(xmin + (i - 0.5) * dx); lock (monitor) { result += s; } });
        forFnc(1, steps,     i => { double s = 2 * fnc(xmin + i * dx);         lock (monitor) { result += s; } });

А то не сильно он параллелился :)

[cupuyc]

Maslov, ну и как, параллельный код быстрей считается? Во сколько раз (и на скольких процессорах), не замеряли?

[nestoklon]

(Оффтоп)

cupuyc в сообщении #419419 писал(а):

Учитывая, что мой опыт программирования на эрланге к тому времени был около недели - вполне ожидаемая ошибка.

Что же будет, когда Вы откроете для себя питон... Страшно представить.

cupuyc в сообщении #419419 писал(а):

Зачем Вы всё в одну строчку пишите?

Потому что так принято. Был бы олдскульным китайцем -- писал бы в столбик.

cupuyc в сообщении #419419 писал(а):

Полезного кода 3 строчки. Что делает остальной код?

Ну у вас-то и того нет, без обид. Полезная строчка равномерно размазана по 10 функциям и 40 строчкам. Очень удобно, да.

cupuyc в сообщении #419419 писал(а):

Тогда для меня вообще загадка - что делает весь Ваш код.

А Вы его читать пробовали?

[cupuyc]

nestoklon в сообщении #419431 писал(а):

А Вы его читать пробовали?

, пробовал. Не понял к чему столько шаблонных классов, если используются лямбда функции. Какова цель - наплодить кучу сущностей?

nestoklon в сообщении #419431 писал(а):

Ну у вас-то и того нет, без обид.

Тут Вы правы. У меня нет столько бесполезного кода.

nestoklon в сообщении #419431 писал(а):

Полезная строчка равномерно размазана по 10 функциям и 40 строчкам. Очень удобно, да.

Тут Вы ошибаетесь. Каждая функция выполняет некоторое вполне осмысленное действие. Алгоритм не размазан по функциям от одного только желания.

-- Пт мар 04, 2011 02:06:56 --

(Оффтоп)

nestoklon в сообщении #419431 писал(а):

Потому что так принято. Был бы олдскульным китайцем -- писал бы в столбик.

Код от этого понятней не становится.

nestoklon в сообщении #419431 писал(а):

Что же будет, когда Вы откроете для себя питон... Страшно представить.

Открывал.

[nestoklon]

cupuyc в сообщении #419434 писал(а):

Не понял к чему столько шаблонных классов

1 (один!!!) шаблонный класс. Там есть один шаблонный класс. Когда я Вам говорю, что С это не С++, Вы говорите что нет никакой разницы. Когда я Вам эту разницу показываю, Вы спрашиваете "а зачем тут шаблоны?". Блин, да потому что это не С!

cupuyc в сообщении #419434 писал(а):

У меня нет столько бесполезного кода.

Угу, потому что его за Вас наплодили авторы языка. Ладно, я всё понял. Это не лечится. Удачи с Эрлангом. Особенно рекомендую обратить внимание на производительность. Могут быть неожиданные открытия.

[cupuyc]

nestoklon в сообщении #419441 писал(а):

Когда я Вам говорю, что С это не С++, Вы говорите что нет никакой разницы.

Не врите, я такого не говорил. Языки совершенно разные. Я говорил, что в обоих языках будут одни и те же проблемы.

-- Пт мар 04, 2011 02:22:34 --

nestoklon в сообщении #419441 писал(а):

1 (один!!!) шаблонный класс.

Тут даже один класс не нужен (хотя, Вы врёте, у Вас не один класс описан). Тут вообще классы не нужны. С лямбда функциями задача решается написанием одной (!!!) функции, для расчёта значения интеграла. Зачем тут классы? Вот venco решил задачу без лямбда функций - пришлось возиться с бустовским boost:lambda, поэтому и получилось такое нагромождение шаблонов. Когда я увидел кучу шаблонов в Вашем коде, я поначалу подумал, что Вы эти шаблоны написали вместо бустовских. А оказалось, что Вы использовали лямбда функции, да ещё и написали кучу бесполезных классов. Вот я и не пойму - зачем.

nestoklon в сообщении #419441 писал(а):

Особенно рекомендую обратить внимание на производительность.

Вы сами обращали? Сдаётся мне что Ваши утверждения голословны.

[nestoklon]

cupuyc в сообщении #419443 писал(а):

С лямбда функциями задача решается написанием одной (!!!) функции, для расчёта значения интеграла. Зачем тут классы?

У Maslov спросите, он знает.

[cupuyc]

nestoklon в сообщении #419456 писал(а):

cupuyc в сообщении #419443 писал(а):

С лямбда функциями задача решается написанием одной (!!!) функции, для расчёта значения интеграла. Зачем тут классы?

У Maslov спросите, он знает.

При чём здесь Maslov? Не уходите от ответа. У него задача решена без всяких дополнительных ненужных классов.

-- Пт мар 04, 2011 03:27:24 --

Я тут подумал над Вашим заявлением

nestoklon в сообщении #419412 писал(а):

Передавать оператор суммы -- это жесть.

Всё-таки у меня правильно сделано. В эрланге таким образом реализуется концепция метапрограммирования. Жаль, конечно, нет возможности посмотреть ассемблерный код, генерируемый эрлангом, но вполне верятно, что никакой указатель на функцию в качестве аргументов другой функции не передаётся. Вполне возможно это всё решается в compile time. Так что Ваша критика совершенно не обоснована.

[Maslov]

cupuyc в сообщении #419428 писал(а):

Maslov, ну и как, параллельный код быстрей считается? Во сколько раз (и на скольких процессорах), не замеряли?

Да, Вы и venco были правы: параллельный вариант считается быстрее. На четырех ядрах разница от 2-х до 4-х раз (в зависимости от соотношения количество точек во внешнем и внутреннем интегралах).

Кстати, вот ещё один эрланговский вариант (по мотивам C#):

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

-module(simps).
-export([parSimpson/4, seqSimpson/4]).
-compile([native]).
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% exports API
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-spec(parSimpson/4 :: (From :: float(), To :: float(), N :: integer(), Func :: function()) -> float()).
-spec(seqSimpson/4 :: (From :: float(), To :: float(), N :: integer(), Func :: function()) -> float()).
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% implementation
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
simpson(From, To, N, Func, Map) ->
    Dx = (To - From) / N,
    Dx / 6 * (
        Func(From) + Func(To) + 
        lists:foldl(fun(A, H)->A+H end, 0, Map(fun(I)->4*Func(From+(I-0.5)*Dx) end, lists:seq(1, N))) +
        lists:foldl(fun(A, H)->A+H end, 0, Map(fun(I)->2*Func(From+I*Dx) end,       lists:seq(1, N-1)))
    ).
 
%% Утащено отсюда: http://bc.tech.coop/blog/070601.html
parmap(F, L) ->
    Parent = self(),
    [receive {Pid, Result} -> Result end || Pid <- [spawn(fun() -> Parent ! {self(), F(X)} end) || X <- L]].
        
parSimpson(From, To, N, Func) ->
    simpson(From, To, N, Func, fun(F, L) -> parmap(F, L) end ).
 
seqSimpson(From, To, N, Func) ->
    simpson(From, To, N, Func, fun(F, L) -> lists:map(F, L) end ).

(Disclaimer)

Если что не так, не судите строго: на эрланге до этого не писал

[cupuyc]

Maslov, мне кажется, что мой вариант эрланговского кода лучше. Я тоже сначала думал сделать через листы. Да, есть функции стандартных библиотек, код получается попроще, но сколько памяти выделяется для сохранения значений! Конечно, чёрт с ней - с памятью, на современных компьютерах её море. Но, опять же, кеш ограничен, стало быть и производительность снизится. В итоге решил написать свой велосипед - функции for, sum, которые не сохраняют промежуточные результаты.

Может ещё что-нибудь решим? Задачу движения объектов солнечной системы, например. Здесь распараллеливание наверняка будет актуально. У меня назревает мысль заюзать GPU для решения этой задачи. Хотя, количество ядер CPU растёт год от года (уже, вроде, и шести ядерные есть), так что может и не имеет особого смысла заморачиваться с GPU.

[cupuyc_]

Собственно, вот плюсная прога с использованием лямбды. Не понятно что Вы, nestoklon, изобретали.

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

#include <iostream>
#include <omp.h>

template <class t_func>
double integral(double const& from, double const& to, t_func const& func, int N = 10000)
{
    double sum = 0.0;
    double const step = (to - from) / (2.0 * N);
    int i;

#pragma omp parallel for 
    for (i = 1; i < N; i ++)
        sum += 2.0 * func(from + (to - from) * i / N);

#pragma omp parallel for
    for (i = 1; i <= N; i ++)
        sum += 4.0 * func(from - step + (to - from) * i / N);

    return step * (sum + func(from) + func(to)) / 3.0;
}

int main()
{
    double const integral_value = integral(0.0, 1.0, [](double const& x){ return integral(sin(x), cos(x), [&x](double const& y) { return x * x * y * (2.0 * x + 3.0 * y); });});
    std::cout << "integral value: " << integral_value << std::endl;
    return 0;
}
 

[nestoklon]

cupuyc_ в сообщении #419552 писал(а):

Не понятно что Вы, nestoklon, изобретали.

1) Я стремился показать как это делается "на с++". Лямбды только для примера использования.
2) А теперь продемонстрируйте, как Вы будете делать карринг функции нескольких переменных. К сожалению для ФП и к счастью для всего остального, функция нескольких переменных на С++ -- это настоящая функция нескольких переменных, а не функция от одного словаря.
Хотя, что я объясняю...

[cupuyc_]

nestoklon в сообщении #419613 писал(а):

1) Я стремился показать как это делается "на с++". Лямбды только для примера использования.

У Вас получилось показать как это делается через то место, за которое мне дали предупреждение. Классы ради классов? сиплюсплюс ради сиплюсплюса? Конечная цель программиста - решить задачу оптимальным образом, а не нагородить кучу классов чтобы они были.

nestoklon в сообщении #419613 писал(а):

2) А теперь продемонстрируйте, как Вы будете делать карринг функции нескольких переменных. К сожалению для ФП и к счастью для всего остального, функция нескольких переменных на С++ -- это настоящая функция нескольких переменных, а не функция от одного словаря.

Остапа понесло... Во-первых, не уходите от темы. Во-вторых, что такое "настоящая функция нескольких переменных"? Бывают ещё "игрушечные функции нескольких переменных"?

[nestoklon]

cupuyc_ в сообщении #419616 писал(а):

Конечная цель программиста - решить задачу оптимальным образом, а не нагородить кучу классов чтобы они были.

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

cupuyc_ в сообщении #419616 писал(а):

Во-вторых, что такое "настоящая функция нескольких переменных"? Бывают ещё "игрушечные функции нескольких переменных"?

Нет, бывают недофункции, как в функциональных языках. Когда функция -- это всегда что-то, что принимает описание аргументов плюс аргументы. Что я и эмулировал первым из необходимых для решения задачи классом.

cupuyc_ в сообщении #419616 писал(а):

а не нагородить кучу классов чтобы они были

Да, я уже спрашивал, зачем Вы наплодили функций, повторяю вопрос. Вы не оценили иронии. Намекну, в ФП оперируют функциями, с ООП -- объектами.

cupuyc_ в сообщении #419616 писал(а):

Во-первых, не уходите от темы.

В принципе, было понятно, что не поймёте. Спрошу попроще. Проинтегрируйте пожалуйста функцию от двух переменных.