Стратегия оценки

В языке программирования стратегия вычисления — это набор правил вычисления выражений. Этот термин часто используется для обозначения более конкретного понятия стратегии передачи параметров. который определяет тип значения, передаваемого функции для каждого параметра ( стратегия привязки ) и следует ли оценивать параметры вызова функции, и если да, то в каком порядке ( порядок оценки ). Понятие стратегии сокращения является четким, хотя некоторые авторы объединяют эти два термина, и определение каждого термина не получило широкого согласия.

Чтобы проиллюстрировать, выполнение вызова функции f(a,b) может сначала оценить аргументы a и b, сохранять результаты в ссылках или ячейках памяти ref_a и ref_b, затем оцените тело функции с переданными ссылками. Это дает функции возможность искать исходные значения аргументов, переданных путем разыменования параметров (некоторые языки используют для этого специальные операторы), чтобы изменять их посредством присваивания, как если бы они были локальными переменными и возвращали значения через ссылки. Это стратегия оценки по ссылке.

Стратегия оценки является частью семантики определения языка программирования. Некоторые языки, такие как PureScript , имеют варианты с разными стратегиями оценки. Некоторые декларативные языки , такие как Datalog , поддерживают несколько стратегий оценки. Некоторые языки определяют соглашение о вызовах .

Стол

Это таблица стратегий оценки и репрезентативных языков по годам введения. Репрезентативные языки перечислены в хронологическом порядке, начиная с языка(ов), на которых была представлена ​​стратегия, и заканчивая известными языками, использующими эту стратегию.

Стратегия оценки	Репрезентативные языки	Год первого представления
Звонок по ссылке	Фортран II, PL/I	1958
Вызов по значению	АЛГОЛ , C , Схема , MATLAB	1960
Звонок по имени	АЛГОЛ 60 , Моделирование	1960
Звонок путем копирования-восстановления	Фортран IV , Да	1962
Звонок по объединению	Пролог	1965
Звонок по необходимости	САСЛ , Хаскелл , Р.	1971
Позвоните, поделившись	CLU , Java , Python , Руби , Джулия	1974
Вызов по ссылочным параметрам	С++ , PHP , С# , Визуальный Бейсик .NET	1985
Вызов по ссылке на const	С++ , С	1985

Заказы на оценку

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

def f(x):
    print(x, end='')
    return x

print(f(1) + f(2),end='')

результаты 123 из-за порядка вычислений Python слева направо, но аналогичная программа в OCaml :

let f x = print_int x; x ;;
print_int (f 1 + f 2)

результаты 213 из-за порядка вычислений OCaml справа налево.

Порядок вычислений в основном виден в коде с побочными эффектами , но он также влияет на производительность кода, поскольку жесткий порядок препятствует планированию инструкций . По этой причине языковые стандарты, такие как C++, традиционно оставляют порядок неопределенным, хотя такие языки, как Java и C#, определяют порядок вычислений слева направо. а стандарт C++17 добавил ограничения на порядок вычислений.

Строгая оценка

Аппликативный порядок — это семейство порядков вычислений, в которых аргументы функции полностью оцениваются перед применением функции. Это приводит к тому, что функция становится строгой , т. е. результат функции не определен, если какой-либо из аргументов не определен, поэтому оценку аппликативного порядка чаще называют строгой оценкой . Более того, вызов функции выполняется, как только он встречается в процедуре, поэтому его также называют нетерпеливой оценкой или жадной оценкой . Некоторые авторы называют строгую оценку «вызовом по значению» из-за стратегии привязки вызова по значению, требующей строгой оценки.

Common Lisp, Eiffel и Java оценивают аргументы функции слева направо. C оставляет порядок неопределенным. Схема требует, чтобы порядок выполнения представлял собой последовательное выполнение неопределенной перестановки аргументов. OCaml аналогичным образом оставляет порядок неопределенным, но на практике аргументы оцениваются справа налево из-за конструкции своей абстрактной машины . Все это строгая оценка.

Нестрогая оценка

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

Во многих языках логические выражения используют форму нестрогого вычисления, называемую сокращенным вычислением , при котором вычисление оценивает левое выражение, но может пропустить правое выражение, если результат может быть определен — например, в дизъюнктивном выражении (ИЛИ), где true встречается или в союзном выражении (И), где false встречается и так далее. Условные выражения аналогично используют нестрогое вычисление — оценивается только одна из ветвей.

Сравнение аппликативного порядка и оценки нормального порядка

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

Стратегии строгого связывания

Вызов по значению

При вызове по значению (или передаче по значению) вычисленное значение выражения аргумента привязывается к соответствующей переменной в функции (часто путем копирования значения в новую область памяти). Если функция или процедура могут присваивать значения своим параметрам, присваивается только ее локальная переменная, т. е. все, что передается в вызов функции, остается неизменным в области вызывающего объекта при возвращении функции. Например, в Pascal передача массива по значению приведет к копированию всего массива, и любые изменения в этом массиве будут невидимы для вызывающей стороны:

program Main;
uses crt;

procedure PrintArray(a: Array of integer);
var
  i: Integer;
begin
  for i := Low(a) to High(a) do
    Write(a[i]);
  WriteLn();
end;

Procedure Modify(Row : Array of integer);  
begin  
  PrintArray(Row); // 123
  Row[1] := 4;
  PrintArray(Row); // 143
end;

Var
  A : Array of integer; 
begin
  A := [1,2,3];
  PrintArray(A); // 123
  Modify(A);
  PrintArray(A); // 123
end.

Семантический дрейф

Строго говоря, при вызове по значению никакие операции, выполняемые вызываемой подпрограммой, не могут быть видны вызывающей стороне, кроме как как часть возвращаемого значения. Это подразумевает форму чисто функционального программирования в семантике реализации. Однако оборот «вызов по значению, где значение является ссылкой» стал обычным явлением, например, в сообществе Java. По сравнению с традиционной передачей по значению, передаваемое значение — это не значение в его обычном значении, например целое число, которое можно записать как литерал, а внутренний дескриптор ссылки реализации . Изменения этого дескриптора ссылки видны в вызывающем объекте. Из-за видимой мутации эту форму «вызова по значению» правильнее называть вызовом путем совместного использования .

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

Звонок по ссылке

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

Из-за различий в синтаксисе разница между вызовом по ссылке (где ссылочный тип является неявным) и вызовом путем совместного использования (где ссылочный тип является явным) на первый взгляд часто неясна. Простой лакмусовой бумажкой является возможность написать традиционный swap(a, b) функционировать в языке. Например, на Фортране:

program Main
    implicit none
    integer :: a = 1
    integer :: b = 2
    call Swap(a, b)
    print *, a, b ! 2 1
contains
    subroutine Swap(a, b)
        integer, intent(inout) :: a, b
        integer :: temp
        temp = a
        a = b
        b = temp
    end subroutine Swap
end program Main

Таким образом, Фортран inout намерение реализует вызов по ссылке; любая переменная может быть неявно преобразована в ссылочный дескриптор. Напротив, самое близкое, что можно получить в Java:

class Main {
    static class Box {
        int value;
        public Box(int value) {
            this.value = value;
        }
    }
    static void swap(Box a, Box b) {
        int temp = a.value;
        a.value = b.value;
        b.value = temp;
    }
    public static void main(String[] args) {
        Box a = new Box(1);
        Box b = new Box(2);
        swap(a, b);
        System.out.println(String.format("%d %d", a.value, b.value));
    }
}
// output: 2 1

где явное Box type должен использоваться для введения дескриптора. Java использует вызов путем совместного использования, но не вызов по ссылке.

Звонок путем копирования-восстановления

Вызов путем копирования-восстановления, также известный как «копирование-вход-выход», «вызов по результату значения», «вызов по возврату значения» (как это называется в сообществе Fortran ) — это вариант вызова по ссылке. При вызове методом копирования-восстановления содержимое аргумента копируется в новую переменную, локальную для вызова вызова. Затем функция может изменить эту переменную, аналогично вызову по ссылке, но поскольку переменная является локальной, изменения не видны за пределами вызова во время вызова. Когда вызов функции возвращает значение, обновленное содержимое этой переменной копируется обратно, чтобы перезаписать исходный аргумент («восстановлено»).

Семантика вызова путем копирования-восстановления во многих случаях аналогична вызову по ссылке, но отличается, когда два или более аргумента функции псевдонимируют друг друга (т. е. указывают на одну и ту же переменную в среде вызывающего объекта). При вызове по ссылке запись в один аргумент повлияет на другой во время выполнения функции. При вызове путем копирования-восстановления запись в один аргумент не повлияет на другой во время выполнения функции, но в конце вызова значения двух аргументов могут отличаться, и неясно, какой аргумент копируется первым и, следовательно, какое значение получает переменная вызывающего объекта. Например, Ада определяет, что назначение копирования для каждого in out или out параметр встречается в произвольном порядке. Из следующей программы (незаконно в Ada 2012) видно, что поведение GNAT заключается в копировании в порядке слева направо:

with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Copy_Restore is
  procedure Modify (A, B : in out Integer) is
  begin
      A := A + 1;
      B := B + 2;
  end Modify;
  X : Integer := 0;
begin
  Modify(X, X);
  Put_Line("X = " & Integer'Image(X));
end Test_Copy_Restore;
-- $ gnatmake -gnatd.E test_copy_restore.adb; ./test_copy_restore
-- test_copy_restore.adb:12:10: warning: writable actual for "A" overlaps with actual for "B" [-gnatw.i]
-- X = 2

Если бы программа вернула 1, она бы копировала справа налево, а при вызове по семантике ссылки программа вернула бы 3.

Когда ссылка передается вызывающей стороне неинициализированной (например, out параметр в Ada в отличие от in out параметр), эту стратегию оценки можно назвать «вызов по результату».

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

Позвоните, поделившись

Вызов путем совместного использования (также известный как «передача путем совместного использования», «вызов по объекту» или «вызов путем совместного использования объекта») — это стратегия оценки, которая является промежуточной между вызовом по значению и вызовом по ссылке. Вместо того, чтобы каждая переменная представлялась как ссылка, только определенный класс значений, называемый «ссылками», « коробочными типами » или «объектами», имеет ссылочную семантику, и именно адреса этих указателей передаются в функцию. . Как и вызов по значению, значение переданного адреса является копией, а прямое присвоение параметру функции перезаписывает копию и не отображается для вызывающей функции. Как и вызов по ссылке, изменение цели указателя видно вызывающей функции. Мутации изменяемого объекта внутри функции видны вызывающей стороне, поскольку объект не копируется и не клонируется — он является общим , отсюда и название «вызов путем совместного использования».

Впервые этот метод был описан Барбарой Лисковой в 1974 году для языка CLU . Он используется во многих современных языках, таких как Python (общие значения называются «объектами»), Java (объекты), Ruby (объекты), JavaScript (объекты), Scheme (структуры данных, такие как векторы), AppleScript (списки, записи, даты и объекты сценариев), OCaml и ML (ссылки, записи, массивы, объекты и другие составные типы данных), Maple (таблицы и таблицы) и Tcl (объекты). Термин «вызов путем совместного использования», используемый в этой статье, не широко используется; терминология противоречива в разных источниках. Например, в Java-сообществе говорят, что Java — это вызов по значению.

Для неизменяемых объектов нет реальной разницы между вызовом путем совместного использования и вызовом по значению, за исключением случаев, когда идентификатор объекта виден в языке. Использование вызова путем совместного использования с изменяемыми объектами является альтернативой параметрам ввода/вывода : параметр не назначается (аргумент не перезаписывается и идентификатор объекта не изменяется), но объект (аргумент) мутируется.

Например, в Python списки изменяемы и передаются при вызове путем совместного использования, поэтому:

def f(a_list):
    a_list.append(1)

m = []
f(m)
print(m)

результаты [1] потому что append Метод изменяет объект, для которого он вызывается.

Напротив, присвоения внутри функции не заметны для вызывающей стороны. Например, этот код привязывает формальный аргумент к новому объекту, но он не виден вызывающей стороне, поскольку не изменяется. a_list:

def f(a_list):
    a_list = a_list + [1]
    print(a_list) # [1]

m = []
f(m)
print(m) # []

Звонок по адресу

Вызов по адресу , передача по адресу или вызов/передача по указателю — это метод передачи параметра, при котором адрес аргумента передается как формальный параметр. Внутри функции адрес (указатель) может использоваться для доступа или изменения значения аргумента. Например, операция замены может быть реализована в C следующим образом:

#include <stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a = 1;
    int b = 2;
    swap(&a, &b);
    printf("%d %d", a, b); // 2 1
    return 0;
}

Некоторые авторы рассматривают & как часть синтаксиса вызова swap. С этой точки зрения C поддерживает стратегию передачи параметров по ссылке. Другие авторы придерживаются иной точки зрения, что представленная реализация swap в C — это всего лишь симуляция вызова по ссылке с использованием указателей. С этой точки зрения «симуляции» изменяемые переменные в C не являются первоклассными (то есть l-значения не являются выражениями), а типы указателей. С этой точки зрения представленная программа подкачки является синтаксическим сахаром для программы, которая повсюду использует указатели. например эта программа( read и assign были добавлены, чтобы подчеркнуть сходство с Java Box программа совместного вызова выше ):

#include <stdio.h>

int read(int *p) {
  return *p;
}

void assign(int *p, int v) {
  *p = v;
}

void swap(int* a, int* b) {
    int temp_storage; int* temp = &temp_storage;
    assign(temp, read(a));
    assign(a, read(b));
    assign(b, read(temp));
}

int main() {
    int a_storage; int* a = &a_storage;
    int b_storage; int* b = &b_storage;
    assign(a,1);
    assign(b,2);
    swap(a, b);
    printf("%d %d", read(a), read(b)); // 2 1
    return 0;
}

Потому что в этой программе swap работает с указателями и не может изменять сами указатели, а только те значения, на которые указывают указатели. Эта точка зрения предполагает, что основная стратегия оценки C больше похожа на совместное использование вызова.

C++ еще больше запутывает проблему, позволяя swap должен быть объявлен и использован с очень легким «эталонным» синтаксисом:

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 1;
    int b = 2;
    swap(a, b);
    std::cout << a << b << std::endl; // 2 1
    return 0;
}

Семантически это эквивалентно примерам на C. Таким образом, многие авторы считают вызов по адресу уникальной стратегией передачи параметров, отличной от вызова по значению, вызова по ссылке и совместного использования.

Звонок по объединению

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

Стратегии нестрогого связывания

Звонок по имени

Вызов по имени — это стратегия оценки, при которой аргументы функции не оцениваются до ее вызова — скорее, они подставляются непосредственно в тело функции (с использованием подстановки, избегающей захвата ), а затем оставляются для оценки всякий раз, когда они появляются в функция. Если аргумент не используется в теле функции, он никогда не оценивается; если он используется несколько раз, он пересчитывается каждый раз, когда появляется. ( см. в устройстве Дженсена Технику программирования, которая использует это, .)

Оценка вызова по имени иногда предпочтительнее оценки вызова по значению. Если аргумент функции не используется в функции, вызов по имени сэкономит время, не оценивая аргумент, тогда как вызов по значению все равно оценит его. Если аргумент представляет собой непрерывные вычисления, преимущество огромно. Однако, когда используется аргумент функции, вызов по имени часто происходит медленнее и требует такого механизма, как thunk .

Языки .NET могут имитировать вызов по имени с помощью делегатов или Expression<T> параметры. Последнее приводит к тому, что абстрактное синтаксическое дерево функции передается . Eiffel предоставляет агенты, которые представляют собой операцию, которую необходимо оценить при необходимости. Seed7 обеспечивает вызов по имени с параметрами функции. Программы Java могут выполнять аналогичные ленивые вычисления, используя лямбда-выражения и java.util.function.Supplier<T> интерфейс.

Звонок по необходимости

Основная статья: Ленивая оценка

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

Haskell — хорошо известный язык, использующий оценку по мере необходимости. Поскольку вычисление выражений может происходить на произвольной стадии вычисления, Haskell поддерживает только побочные эффекты (такие как мутации ) посредством использования монад . Это исключает любое неожиданное поведение переменных, значения которых изменяются до их отложенной оценки.

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

Ленивая оценка — это наиболее распространенная реализация семантики вызова по необходимости, но существуют ее варианты, такие как оптимистическая оценка . Языки .NET реализуют вызов по необходимости, используя тип Lazy<T>.

Сокращение графа — это эффективная реализация ленивых вычислений.

Вызов с помощью расширения макроса

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

Звонок в будущее

«Звонок по будущему», также известный как «параллельный вызов по имени» или «снисходительная оценка», — это стратегия параллельной оценки, сочетающая нестрогую семантику с нетерпеливой оценкой. Этот метод требует детального динамического планирования и синхронизации, но подходит для машин с массовым параллелизмом.

Стратегия создает будущее (обещание) для тела функции и каждого из ее аргументов. Эти фьючерсы вычисляются одновременно с остальной частью программы. Когда фьючерсу A требуется значение другого фьючерса B, которое еще не было вычислено, фьючерс A блокируется до тех пор, пока фьючерс B не завершит вычисление и не получит значение. Если будущий B уже завершил вычисления, значение возвращается немедленно. Условные выражения блокируются до тех пор, пока их условие не будет оценено, а лямбда-выражения не создают фьючерсы до тех пор, пока они не будут полностью применены.

Если оно реализовано с помощью процессов или потоков, создание будущего порождает один или несколько новых процессов или потоков (для промисов), доступ к значению синхронизирует их с основным потоком, а прекращение вычисления будущего соответствует уничтожению промисов, вычисляющих его. ценить. Если реализовано с помощью сопрограммы , как в .NET async/await , создание будущего вызывает сопрограмму (асинхронную функцию), которая может передаваться вызывающему объекту и, в свою очередь, возвращаться обратно при использовании значения, обеспечивая совместную многозадачность.

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

f x = 1/x
g y = 1
main = print (g (f 0))

может иметь g закончить раньше fи выход 1, или может привести к ошибке из-за вычисления 1/0.

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

Оптимистическая оценка

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

См. также

• Бета-нормальная форма
• Сравнение языков программирования
• оценивать
• Лямбда-исчисление
• Вызов по значению push
• Частичная оценка

Дальнейшее чтение

• Бейкер-Финч, Клем; Король, Дэвид; Холл, Джон; Триндер, Фил (10 марта 1999 г.). «Операционная семантика для параллельного вызова по необходимости» (ps) . Отчет об исследовании . 99 (1). Факультет математики и информатики Открытого университета.
• Энналс, Роберт; Пейтон Джонс, Саймон (2003). Оптимистическая оценка: стратегия быстрой оценки нестрогих программ (PDF) . Международная конференция по функциональному программированию. АКМ Пресс.
• Людешер, Бертрам (24 января 2001 г.). «Конспекты лекций CSE 130» . CSE 130: Языки программирования: принципы и парадигмы .
• Пирс, Бенджамин К. (2002). Типы и языки программирования . МТИ Пресс . ISBN  0-262-16209-1 .
• Сестофт, Питер (2002). Могенсен, Т; Шмидт, Д; Садборо, Айдахо (ред.). Демонстрация сокращения лямбда-исчисления (PDF) . Конспекты лекций по информатике. Том. 2566. Шпрингер-Верлаг. стр. 420–435. ISBN  3-540-00326-6 . {{cite book}}: |work= игнорируется ( помогите )
• «Вызов по значению и вызов по ссылке в программировании на C» . Объяснение вызова по значению и вызову по ссылке в программировании на C. Архивировано из оригинала 21 января 2013 г.

Внешние ссылки

• Интерактивный онлайн- «Геометрия взаимодействия» визуализатор , реализующий графическую машину для нескольких распространенных стратегий оценки.