В чем отличие процедурного программирования от функционального?

«В оптических системах могут производиться операции умножения вектора на матрицу, вычисление корреляционных функций, выполняться преобразование Фурье и другие операции.»

Как тебе Фурье за 1 такт? Разве плохо?

Если объяснишь, что это такое, объясню, как на С реализовать.

Бред полный при чем тут это? При наличие в языке static и глобальных переменных про ссылочную прозрачность и идемпотеность сразу можно забыть.

Бред полный при чем тут это?

А что ты тогда хочешь увидеть?

При наличие в языке static и глобальных переменных про ссылочную прозрачность и идемпотеность сразу можно забыть.

Ну так не используй никаких static и глобальных переменных

Если объяснишь, что это такое, объясню, как на С реализовать.

Ты должен выполнить контракт с компилятором. Что он твои функции в целях оптимизации может вызывать в произвольном порядке и произвольных тредах, параллельно или последовательно решает он сам. Да еще, циклы использовать нельзя, у тебя их нет.

Использование циклов запрещено.

Что он твои функции в целях оптимизации может вызывать в произвольном порядке и произвольных тредах, параллельно или последовательно решает он сам.

Что-то похожее есть в атрибутах к функциям в GCC https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html

const

Calls to functions whose return value is not affected by changes to the observable state of the program and that have no observable effects on such state other than to return a value may lend themselves to optimizations such as common subexpression elimination. Declaring such functions with the const attribute allows GCC to avoid emitting some calls in repeated invocations of the function with the same argument values.

For example,

int square (int) __attribute__ ((const));

tells GCC that subsequent calls to function square with the same argument value can be replaced by the result of the first call regardless of the statements in between.

Использование циклов запрещено.

Циклы и рекурсия взаимозаменяемы, если ты не знала

Напиши в С вычисление факториала через рекурсию для 10000. Потом поговорим.

Ты ещё про Тезис Черча [s]ей[/s]ему расскажи. Утонченное наслаждение: кормить на ЛОРе явного тролля.

$ cat fact.c
#include <stdio.h>
int fact_helper(n, a) {
  if (n == 0) {
    return a;
  } else {
    return fact_helper(n-1, n*a);
  }
}
int fact(int n) {
  return fact_helper(n, 1);
}
int main() {
  printf("Int(10000!) = %d\n", fact(10000));
  return 0;
}
MigMit:~ migmit$ ./fact
Int(10000!) = 0

Можно, конечно, и непереполняющуюся арифметику реализовать, но надо ли?

И почему у тебя стек не переполняется?

int fact_helper(n, a)

Ошибка.

Ну, с того же, с чего он не будет переполнятся в Хаскеле в аналогичной ситуации.

И почему у тебя стек не переполняется?

А ты слышала что-нибудь про tail-call optimization? Почитай, думаю пригодится.

И в каком месте стандарта С сказано про оптимизацию хвостовой рекурсии?

Ошибка, но на самом деле нет. Старый синтаксис C позволяет так писать.

Не сказано, но нормальные люди делают. Собственно, если не ошибаюсь, стандарт Haskell 98 тоже про неё не говорит.

Лучше как-нибудь так:

unsigned int fact( unsigned int n) { return n < 1 ? 1 : n*fact(n-1); }

Можно конечно свои бигинты накостылить, но мне лень

А вот это уже должно бы переполниться. Update но не переполняется.

Нет, с оптимизацией не переполняется. Но GCC там две инструкции ret генерит, так что это я в багзиллу GCC зарепортил https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71923

А если inline добавить, то вообще никаких вызовов не останется, будет чисто умножение в цикле. И gcc, и clang.

Хех. Не переполняется (даже с -O0), потому что 10000 — это очень мало. Стека банально хватает.

Иммутабельные данные это тормоза на копирование

А мутабельные — на отладку. И да, полностью копировать не обязательно же.

Но зачем? У компилятора языка C нет такого контракта. Ты хочешь придумать какое-то подмножество C? Ну ради бога, передавай всё через параметры функций. Вместо циклов используй рекурсию.

Хороший мальчик. А теперь давай покажи редьюсер. Только без циклов, чисто на рекурсии. Можно даже не ленивый, простой такой редьюсер.

Хочешь чтоб я для тебя бесплатно рантайм функционального языка на сишке написал?

Вообще-то, да, пора либо аргументы предъявлять, либо дензнаки.

Просто редьюсер. Что такого?

Что такое «редьюсер» можно на русском объяснить?

И еще наверно вызовы libc надо в монадку заворачивать? А иначе вся функциональная чистота сразу нафиг. Давайте мальчики, веселье только начинается.

Ахах, хватит уже, не смеши меня.

По поводу «libc в монадку» - в libc вполне есть фунции, которые никаких сайд-эффектов не имеют. Синусы-косинусы например. Так что не все вызовы libc в монадку надо заворачивать. Впрочем, как и в каком-нибудь хаскеле, там далеко не все функции в монадках.

Ну и заниматься реализацией всякой функциональной фигни в Си просто так я не буду. У меня есть дела поважнее.

Я хз если честно, прогуляла, а гуглить лень :)) Знаю что еще есть трансдьюсеры это еще одна мегапримочка из мира функцинальных языков.

Ну кстати я так и подумал, у тебя там наверно домашка что надо редьюсер на Си написать, вот ты и решила так схитрить

А это разве я сказала, что на С можно писать как на функциональном языке?

надо редьюсер на Си написать

Да ладно, редьюсер, си. Слова какие-то непонятные пишете. Банально старший слесарь дал задание редуктор разобрать, смазать и собрать назад. Но должно же у человека быть место мечте.

Не обманывай нас!

Похоже ты просто путаешь операцию свёртки с мифическим «редьюсером», что ты подразумеваешь под «трансдьюсером» я вообще страшусь представить.

Что до определения - ну на тебе его из той самой лекции:

:) Что такое архитектура фон Неймана не знаешь.

доступно и массово в низкоуровневом кодинге можно не использовать «языки модели фон Неймана»?

То, что ты на «языке модели фон Неймана» настраиваешь DMA-контроллер, (кольцевые) буферы всяких разных карт для ускорения графики, звука, видео и вешаешься на прерывания - это не про модель фон-неймана. Для этого подойдет любой язык, умеющий генерить машинный код.

Когда-то напрямую читали-писали порты ввода-вывода (или замапленные блоки памяти). Вот это более-менее фон-Нейман. Давай, показывай свою скорость 3d-графики, прорисовывая сцены на ЦПУ. Показывай скорость чтения/записи на диски через PIO (prorgammed i/o). И смотри, чтобы курсор мышки не подвисал, когда записываешь на сбойную дискету 1.44.

Вот где мощь и скорость фон-Неймана.

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

А это разве я сказала, что на С можно писать как на функциональном языке?

Я так тоже не говорил. Но вообще следует точно разобраться. Что именно ты понимаешь под «на С можно писать как на функциональном языке»? Например, считаешь ли ты, что возможен некоторый код на функциональном языке, который нельзя какими-либо методами оттранслировать в код на Си, делающий то же самое?

Не. Вот:

A reducer is the combination of a reducible collection (a collection that knows how to reduce itself) with a reducing function (the «recipe» for what needs to be done during the reduction). The standard sequence operations are replaced with new versions that do not perform the operation but merely transform the reducing function. Execution of the operations is deferred until the final reduction is performed. This removes the intermediate results and lazy evaluation seen with sequences.

Transducers are composable algorithmic transformations. They are independent from the context of their input and output sources and specify only the essence of the transformation in terms of an individual element. Because transducers are decoupled from input or output sources, they can be used in many different processes - collections, streams, channels, observables, etc. Transducers compose directly, without awareness of input or creation of intermediate aggregates.

Функция возвращающая новую функцию. Это каррирование.

А в чём проблема?

#include <stdio.h>

typedef int (*reduce_function)(int x, int y);

int reduce(reduce_function f, int z, int *xs, int *xe)
{
    return xs == xe ? z : reduce(f, f(z, *xs), xs + 1, xe);
}

int r(int x, int y)
{
    return x * 2 + y;
}

int main()
{
    int xs[] = {1, 2, 3};
    int v = reduce(r, 4, xs, xs + 3);
    printf("%d\n", v);
    return 0;
}

И где тут коллекция?

int xs[] = {1, 2, 3};

уровнем абстракции

Это свертка, ты не понимаешь что такое редьюсер, определение выше.

Муть какая-то. Засунь в структуру коллекцию и указатель на функцию и всё.

Функция возвращающая новую функцию. Это каррирование.

Каррирование это частный случай. Комбинирование функций - ну это запросто. Например вот https://wandbox.org/permlink/F7VuPNrJOSrQanCk

Каррирование тоже можно такими костылями организовать

В С разве в функции можно определить новую функцию?

типа auto sum(int x, int y, int z) { return auto sum_1 (int x, int y) {return x+y+z}

Тебе надо передавать пару (функция, контекст) вместо просто функции. Как, собственно, все языки и делают «под капотом».