Интерфейсы

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

Любой объект, который определяет эта функция, является итерируемым и может быть использован во многих функциях, где применяется итерация. Его также можно использовать непосредственно в цикле for, поскольку синтаксис

преобразовывается в

Простым примером является итерируемая последовательность квадратов чисел определенной длины:

Имея только определение iterate, тип Squares уже является довольно мощным. Можно выполнять итерацию всех элементов:

Можно использовать многие встроенные методы, работающие с итерируемыми коллекциями, например in или sum:

Есть еще несколько методов, которые можно расширить, чтобы предоставить Julia больше информации об этой итерируемой коллекции. Нам известно, что элементы в последовательности Squares всегда будут иметь тип Int. Расширяя метод eltype, эту информацию можно передать в Julia, чтобы создавать более специализированный код в более сложных методах. Нам также известно количество элементов в последовательности, поэтому можно также расширить и функцию length:

Теперь когда в Julia требуется собрать все элементы в массив с помощью метода collect, Julia может предварительно выделить Vector{Int} нужного размера вместо того, чтобы отправлять каждый элемент в push! с помощью функции Vector{Any}:

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

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

Кроме того, часто полезно разрешить итерацию коллекции в обратном порядке путем итерации с помощью функции Iterators.reverse(iterator). Однако для фактической поддержки итерации в обратном порядке тип итератора T должен реализовать iterate для Iterators.Reverse{T}. (Учитывая r::Iterators.Reverse{T}, базовым итератором типа T является r.itr.) В приведенном далее примере Squares реализуются методы Iterators.Reverse{Squares}:

Для приведенного выше итерируемого объекта Squares можно легко вычислить i-й элемент последовательности, возведя его в квадрат. Процесс можно представить в виде выражения индексирования S[i]. Чтобы принять такое поведение, Squares просто должен определить функцию getindex:

Кроме того, для поддержки синтаксиса S[begin] и S[end] необходимо определить firstindex и lastindex, чтобы указать первый и последний допустимые индексы, соответственно:

Для многомерного индексирования begin/end, как, например, в a[3, begin, 7], необходимо определить firstindex(a, dim) и lastindex(a, dim) (которые по умолчанию вызывают first и last для axes(a, dim), соответственно).

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

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

Если тип определен как подтип AbstractArray, он наследует очень большой набор разнообразных возможностей, включая итерацию и многомерное индексирование, созданное на базе одноэлементного доступа. Дополнительные сведения о поддерживаемых методах см. на странице руководства, посвященной массивам, и в этом разделе Julia Base.

Ключевым элементом в определении подтипа AbstractArray является тип IndexStyle. Поскольку индексирование является важной частью массива и часто встречается в горячих циклах, важно максимально эффективно выполнять как индексирование, так и индексированное назначение. Структуры данных массивов обычно определяются одним из двух способов: либо они максимально эффективно получают доступ к своим элементам, используя только один индекс (линейное индексирование), либо они внутренним образом получают доступ к элементам с индексами, заданными для каждого измерения. Эти два варианта в Julia называются IndexLinear() и IndexCartesian(). Преобразование линейного индекса в несколько нижних индексов обычно является очень дорогостоящей операцией, поэтому существует основанный на признаках механизм, позволяющий создавать эффективный универсальный код для всех типов массивов.

Это различие определяет, какие методы скалярного индексирования должен определять тип. Массивы IndexLinear() просты: достаточно определить getindex(A::ArrayType, i::Int). Когда массив впоследствии индексируется с помощью многомерного набора индексов, резервный getindex(A::AbstractArray, I...) преобразует индексы в один линейный индекс и затем вызывает вышеуказанный метод. Массивам IndexCartesian(), с другой стороны, требуется определять методы для каждой поддерживаемой размерности с индексами ndims(A) Int. Например, тип SparseMatrixCSC из модуля стандартной библиотеки SparseArrays поддерживает только два измерения, поэтому он просто определяет getindex(A::SparseMatrixCSC, i::Int, j::Int). То же самое относится и к setindex!.

Если взять последовательность квадратов, приведенную выше, ее можно определить как подтип AbstractArray{Int, 1}:

Обратите внимание: очень важно указать два параметра AbstractArray. Первый определяет функцию eltype, а второй — функцию ndims. Этот супертип и эти три метода — все, что нужно, для того, чтобы SquaresVector стал итерируемым, индексируемым и полностью функциональным массивом:

Возьмем более сложный пример и определим собственный модельный N-мерный разреженный тип массива, созданный на основе Dict:

Обратите внимание, что это массив IndexCartesian, поэтому нужно вручную определить getindex и setindex! в размерности массива. В отличие от SquaresVector, можно определить setindex! и поэтому можно изменять массив:

Результат индексирования AbstractArray сам может быть массивом (например, при индексировании по AbstractRange). Резервные методы AbstractArray используют функцию similar для выделения Array соответствующего размера и типа элементов, который заполняется с помощью базового метода индексирования, описанного выше. Однако при реализации оболочки массива часто требуется, чтобы результат также был заключен в оболочку:

В приведенном примере это достигается путем определения Base.similar(A::SparseArray, ::Type{T}, dims::Dims) where T для создания соответствующего заключенного в оболочку массива. (Обратите внимание, что, хотя similar поддерживает одно- и двухаргументные формы, в большинстве случаев нужно специализировать только трехаргументную форму.) Для этого важно, чтобы SparseArray был изменяемым (поддерживал setindex!). Определив similar, getindex и setindex! для SparseArray, скопировать массив с помощью функции copy:

Помимо всех приведенных выше итерируемых и индексируемых методов, эти типы также могут взаимодействовать друг с другом и использовать большинство методов, определенных в Julia Base для AbstractArrays:

Если вы определяете тип массива, который допускает нетрадиционное индексирование (индексы, начинающиеся со значения, отличного от 1), необходимо специализировать axes. Также следует специализировать similar, чтобы аргумент dims (обычно кортеж размеров Dims) мог принимать объекты AbstractUnitRange, возможно, диапазонные типы Ind вашей собственной разработки. Дополнительные сведения см. в главе Массивы с пользовательскими индексами.

Массив с заданным шагом — это подтип массива AbstractArray, записи которого хранятся в памяти с фиксированными шагами. При условии, что тип элемента массива совместим с BLAS, массив с заданным шагом может использовать подпрограммы BLAS и LAPACK для более эффективных процедур линейной алгебры. Стандартным примером определяемого пользователем массива с заданным шагом является массив, который заключает стандартный массив Array в дополнительную структуру.

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

Ниже приведены примеры типов массивов с заданными шагами и без них.

Трансляция активируется явным вызовом broadcast или broadcast! либо неявным образом с помощью точечных операций, таких как A .+ b или f.(x, y). Любой объект, имеющий axes и поддерживающий индексирование, может участвовать в качестве аргумента в трансляции. По умолчанию результат сохраняется в Array. Существует три основных способа расширяемости этой базовой платформы:

axes и индексирование поддерживаются не всеми типами, но многие можно разрешать в трансляции. Функция Base.broadcastable вызывается для каждого транслируемого аргумента, что позволяет возвращать что-то другое, поддерживающее axes и индексирование. По умолчанию это функция тождества для всех AbstractArray и Number — они уже поддерживают axes и индексирование.

Если тип должен выступать в роли «0-мерного скаляра» (отдельного объекта), а не контейнера для трансляции, то необходимо определить следующий метод:

который возвращает аргумент, заключенный в 0-мерный контейнер Ref. Например, такой метод-оболочка определен для самих типов, функций, специальных одинарных объектов, таких как missing и nothing, и дат.

Пользовательские массивоподобные типы могут специализировать Base.broadcastable для определения своей формы, но они должны следовать соглашению о том, что collect(Base.broadcastable(x)) == collect(x). Существенным исключением является AbstractString. Строки имеют специальный регистр, чтобы действовать как скаляры для целей трансляции, хотя они являются итерируемыми коллекциями своих символов (подробнее см. в разделе Строки).

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

Иногда желательно изменить способ взаимодействия конечного пользователя с полями объекта. Вместо предоставления прямого доступа к полям типа можно ввести дополнительный уровень абстракции между пользователем и кодом, перегрузив object.field. Свойства — это то, как пользователь видит объект, а поля — то, что объект на самом деле представляет собой.

По умолчанию свойства и поля совпадают. Однако это поведение можно изменить. Например, возьмем представление точки на плоскости в полярных координатах:

Как описывалось в таблице выше, доступ через точечную нотацию p.r равносилен вызову getproperty(p, :r), который по умолчанию равносилен getfield(p, :r):

Однако нам может потребоваться, чтобы пользователи не знали о том, что координаты в Point хранятся как r и ϕ (поля), а вместо этого взаимодействовали с x и y (свойствами). Можно определить методы в первом столбце, добавив новую функциональность:

Важно использовать внутри getproperty и setproperty! вызовы getfield и setfield вместо точечного синтаксиса, так как точечный синтаксис сделает функции рекурсивными, что может привести к проблемам с выводом типов. Теперь можно испытать новую функциональность:

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