Шпаргалка по типам Julia для инженеров и не только

Введение

Эта статья призвана помочь и тем, кто уже давно использует Julia, и тем, кто только начинает её изучать. Благо совсем скоро начнётся Зимняя школа Julia, где можно будет познакомиться с этим по-настоящему замечательным языком.

Мой путь к написанию этой статьи лежал через погружение в работу с массивами, векторами и матрицами в Engee – среде расчётов и моделирования, в которой Julia является основным языком. И в сообществе которой лежит код этой статьи.

Синтаксис, похожий на Python и MATLAB, позволял мне спокойно работать над инженерными проектами, совмещая скрипты и визуальное моделирование. Но мне было сложно понять, почему вектор-столбец

v = [1      2      3]

— вектор размера (3,), а вектор-строка m = [1 2 3] — матрица размера (1,3).

И зная о том, что Julia — это крайне эффективный для вычислений язык, я допускал классические ошибки:

a = collect(1:10) for i in a     ... end

Ведь в MATLAB это было реализовано именно так (в нём range — это массив):

По прочтении этой статьи вы поймёте, почему не стоит использовать collect там, где это не нужно.

Но потом мне стало интересно, как же range, занимая всего 48 байт, обладает всем функционалом массива в виде индексации, сортировки и пр:

sizeof([2:0.5:100;])  # 1546 байт sizeof(2:0.5:100)     # 48   байт

И, погрузившись в документацию, благо она переведена на русский, я пошёл искать ответы на то, почему Julia так здорово работает с range.

В итоге «искал медь, а нашёл золото». Оказывается, система типов в Julia действительно очень интересная.

Было бы странно переписывать документацию на Хабр, поэтому

эта статья призвана собрать в одном месте и в общих чертах (но с неочевидными иногда особенностями) описать систему типов и их предназначение в Julia.

А также получить ответы на вопросы, поставленные выше.

Типы в Julia

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

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

• Примитивный тип: тип, определяемый с помощью ключевого слова primitive type. Объекты примитивного типа имеют заданный фиксированный размер памяти, указанный в определении типа. 📝Int64,Bool,Char

• Составной тип: тип, определяемый с помощью ключевого слова struct. Составные типы состоят из нуля или более полей, ссылающихся на другие объекты (примитивного или составного типа).📝Complex,Rational (поля re, im и num, den, соответственно), Tuple

• Конкретный тип: примитивный или составной тип.

• Абстрактный тип: тип, определяемый с помощью ключевого слова abstract type. Абстрактные типы не имеют полей, и объекты не могут быть созданы (инстанцированы) на их основе. Кроме того, они не могут быть объявлены дочерними по отношению к конкретному типу. Также к абстрактным типам относятся не конкретные типы.📝 Number, AbstractFloat

• Изменяемый тип: составной тип, определяемый с помощью ключевого слова mutable struct. Изменяемые типы могут связывать свои поля с другими объектами, отличными от тех, с которыми они были связаны во время инициализации.📝 String, Dict

• Неизменяемый тип: все типы, кроме тех, которые определяются с помощью mutable struct.

• Параметрический тип: семейство (изменяемых или неизменяемых) составных или абстрактных типов с одинаковыми именами полей и названием типа без учёта типов параметров. Определённый тип затем однозначно идентифицируется по имени параметрического типа и типу (типам) параметра (параметров). 📝 Rational{Int8}(1,2),см. ниже AbstractArray{T,N}, AbstractDict{K,V}

• Исходные типы: тип, определение которого содержится в Julia Base или в стандартной библиотеке Julia

• Битовый тип: примитивный или неизменяемый составной тип, все поля которого являются битовыми типами

• Синглтон: объект, созданный на основе составного типа, состоящего из нуля полей. 📝nothing, missing

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

Примитивный тип

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

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

В качестве примера введём «защищённый от помех из космоса» Bool, который заполняет все возможные доступные битовые ячейки либо 0 либо 1.

При создании примитивного типа необходимо явно указывать, сколько бит требуется для хранения этого типа. (В нашем случае 8)

primitive type FilledBool  8 end  function FilledBool(x::Int)     if iszero(x)         reinterpret(FilledBool,0b00000000)     elseif x == 1         reinterpret(FilledBool,0b11111111)     else          error("В качестве параметров допустимы только 0 и 1")     end end   Base.show(io :: IO, x :: FilledBool) = print(io, bitstring(x))  @show tr = FilledBool(1) @show fls = FilledBool(0) println("Regular Bool true: ", bitstring(true))

tr = FilledBool(1) = 11111111 fls = FilledBool(0) = 00000000 Regular Bool true: 00000001

Проверим, является ли наш тип битовым:

isbitstype(FilledBool) #true

В документации говорится, что вместо того, чтобы создавать собственные примитивные типы — лучше делать обёртку над ними в виде составного типа.
Давайте же познакомимся с ним поближе!

Составной тип

Неизменяемый составной тип

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

Но мы пока сосредоточимся на типах.

Пусть у нас есть тип «Гора». Мы указываем две характеристики объектов этого типа:

• год покорения (год может быть положительным или отрицательным);

• высота горы (предположим, что все горы выше уровня моря).

В неизменяемых типах после их создания нельзя поменять поля.

struct Mountain     first_ascent_year::Int16     height::UInt16 end  Everest = Mountain(1953,8848) Int(Everest.height)  try     Everest.height = 9000  # нельзя менять значения полей Mountain catch e  e end

ErrorException("setfield!: immutable struct of type Mountain cannot be changed")

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

dump(Everest)

Mountain   first_ascent_year: Int16 1953   height: UInt16 0x2290

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

@show sizeof(Mountain) # 2 поля по 2 байта = 4 isbitstype(Mountain)

sizeof(Mountain) = 4 true

Рассмотрим случай, когда полями неизменяемой структуры является не битовый тип.

struct City     name::String end  Moscow = City("Moscow")  Moscow.name  @show sizeof(Moscow) @show sizeof(Moscow.name) @show Base.summarysize(Moscow); 

sizeof(Moscow) = 8 sizeof(Moscow.name) = 6 Base.summarysize(Moscow) = 22

Если требуется использовать статические строки, то

using StaticStrings struct StaticCity     name::StaticString{10} end Moscow = StaticCity(static"Moscow"10) # дополняется \0 до 10 @show sizeof(Moscow) @show sizeof(Moscow.name) @show Base.summarysize(Moscow);

sizeof(Moscow) = 10 sizeof(Moscow.name) = 10 Base.summarysize(Moscow) = 10

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

То есть важно понимать отличие между неизменяемым и битовым типами.

Необычное поведение функции ismutable("123") объясняется здесь.

@show isbitstype(City) @show isbitstype(StaticCity);

isbitstype(City) = false isbitstype(StaticCity) = true

Хочется отдельно отметить, что

неизменяемый тип может иметь неизменяемые поля изменяемого типа.

struct Student     name::String     grade::UInt8        # класс     grades::Vector{Int} # оценки  end  Alex = Student("Alex", 1, [5,5,5])  @show sizeof(Alex)  # 8 + 1 + 8 = 17 => 24 округление до x % 8 == 0

struct Student     name::String     grade::UInt8        # класс     grades::Vector{Int} # оценки  end  Alex = Student("Alex", 1, [5,5,5])  @show sizeof(Alex)  # 8 + 1 + 8 = 17 => 24 округление до x % 8 == 0

sizeof(Alex) = 24 24

pointer(Alex.grades)

push!(Alex.grades,4) Alex.grades # [5, 5, 5, 4] @show pointer(Alex.grades)

push!(Alex.grades,4) Alex.grades # [5, 5, 5, 4] @show pointer(Alex.grades)

Мы меняем элементы вектора, но не указатель на его первый элемент.

# разыменование указателя на вектор (1й элемент вектора) unsafe_load(pointer(Alex.grades)) 

5

А если же мы захотим поменять не элементы вектора, а указатель на вектор, то произойдёт ошибка.

try Alex.grades = [1, 2, 3] # связываем с НОВЫМ вектор catch e     e end

ErrorException("setfield!: immutable struct of type Student cannot be changed")

Изменяемый тип

В случае же изменяемого типа мы можем менять поля.

mutable struct MutableStudent     const name::String     grade::UInt8        # класс     grades::Vector{Int} # оценки end Peter = MutableStudent("Peter", 1, [5,5,5]) Peter.grade = 2

Но есть возможность делать некоторые поля изменяемой структуры неизменяемыми (константными).
В этом случае, несмотря на то, что структура — изменяемая, это поле не получится поменять.

try     Peter.name = "Alex" catch e     e end

ErrorException("setfield!: const field .name of type MutableStudent cannot be changed")

Теперь мы можем менять вектор на другой:

@show pointer(Peter.grades) @show Peter.grades = [2,2,2] @show pointer(Peter.grades)

pointer(Peter.grades) = Ptr{Int64} @0x000000010a12eea0 Peter.grades = [2, 2, 2] = [2, 2, 2] pointer(Peter.grades) = Ptr{Int64} @0x000000010c152f00 Ptr{Int64} @0x000000010c152f00

struct Immutable     a::Int32     b::Int32  end   mutable struct ConstMutable     const a::Int32     const b::Int32 end  im_obj_1 = Immutable(1,2) im_obj_2 = Immutable(1,2)  const_mut_obj_1 = ConstMutable(1,2) const_mut_obj_2 = ConstMutable(1,2) # === означает равенство и значений и адресов в памяти @show im_obj_1 === im_obj_2   @show const_mut_obj_1 === const_mut_obj_2

im_obj_1 === im_obj_2 = true const_mut_obj_1 === const_mut_obj_2 = false

@allocations (a = Immutable(3,4); b = Immutable(3,4)))       # 0   @allocations (a = ConstMutable(3,4); b = ConstMutable(3,4))) # 2

function foo(x,y)     obj1 = Immutable(x,y)     obj2 = Immutable(y,x)     c = obj1.a + obj2.b end function bar(x,y)     obj1 = ConstMutable(x,y)     obj2 = ConstMutable(y,x)     c = obj1.a + obj2.b end println(@allocations foo(1,2)) # 0 println(@allocations bar(1,2)) # 0

Абстрактный тип

Для чего нужны абстрактные типы?
Они нужны для того, чтобы:

• группировать конкретные типы

• задавать интерфейсы для функций

• управлять областью создания других классов при помощи параметризации (см. ниже)

Группирование конкретных типов

Благодаря абстрактным типам можно организовывать иерархии типов.

Рассмотрим классический и наиболее понятный тип — Number.

Используя A <: B Мы можем указывать или проверять то, что тип A является подтипом B

Int8 <: Integer || Int16 <: Integer

true

subtypes(Signed)

6-element Vector{Any}:  BigInt  Int128  Int16  Int32  Int64  Int8

Также можно работать и в обратную сторону:
B :>A показывает — что B является надтипом A

А функция supertypes возвращает упорядоченный слева-направо по возрастанию кортеж надтипов

supertypes(Int8)

(Int8, Signed, Integer, Real, Number, Any)

Но более визуально приятным расширением является пакет AbstractTrees, позволяющий получить многим знакомую картинку.

using AbstractTrees AbstractTrees.children(t::Type) = subtypes(t) print_tree(Number)

Number ├─ MultiplicativeInverse │  ├─ SignedMultiplicativeInverse │  └─ UnsignedMultiplicativeInverse ├─ Complex └─ Real    ├─ AbstractFloat    │  ├─ BigFloat    │  ├─ BFloat16    │  ├─ Float16    │  ├─ Float32    │  └─ Float64    ├─ AbstractIrrational    │  └─ Irrational    ├─ Integer    │  ├─ Bool    │  ├─ Signed    │  │  ├─ BigInt    │  │  ├─ Int128    │  │  ├─ Int16    │  │  ├─ Int32    │  │  ├─ Int64    │  │  └─ Int8    │  └─ Unsigned    │     ├─ UInt128    │     ├─ UInt16    │     ├─ UInt32    │     ├─ UInt64    │     └─ UInt8    └─ Rational 

Однако я рекомендую запустить print_tree(Any) и погрузиться в удивительный мир типов Julia.

Чтобы проверить, указан ли тип как abstract, используйте функцию isabstracttype. Но чтобы понять — является ли тип абстрактным — используйте функцию !isconcretetype(т.е. абстрактный = не конкретный).

Абстрактные типы и множественная диспетчеризация

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

Поэтому в promotion.jl есть следующая строчка:

+(x::Number, y::Number) = +(promote(x,y)...) 

(с помощью methods(+) можно посмотреть что с чем и по каким правилам складывается)

Хотя, например, наименьшее общее кратное должно быть определено только для целочисленных или рациональных. Его мы обсудим в самом конце статьи.

И для тех, кто устал от чисел, предлагаю вернуться к нашим баранам перейти к милым животным:

abstract type Pet end struct Dog <: Pet; name::String end struct Cat <: Pet; name::String end  function encounter(a::Pet, b::Pet)     verb = meets(a, b)     println("$(a.name) встречает $(b.name) и $verb.") end   meets(a::Dog, b::Dog) = "нюхает" meets(a::Dog, b::Cat) = "гонится" meets(a::Cat, b::Dog) = "шипит" meets(a::Cat, b::Cat) = "мурлычит"  fido = Dog("Рекс") rex = Dog("Мухтар") whiskers = Cat("Матроскин") spots = Cat("Бегемот")  encounter(fido, rex)        encounter(fido, whiskers)   encounter(whiskers, rex)    encounter(whiskers, spots)  

Рекс встречает Мухтар и нюхает. Рекс встречает Матроскин и гонится. Матроскин встречает Мухтар и шипит. Матроскин встречает Бегемот и мурлычит. 

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

meets(a::Pet, b::Pet) = "здоровается" struct Cow <: Pet; name::String end encounter(rex,Cow("Бурёнка"))

Мухтар встречает Бурёнка и здоровается.

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

123 isa Integer # true Vector isa DataType || Dict isa DataType # false Function isa DataType # true

Параметрические типы

Параметрическими могут быть как составные, так и абстрактные и даже примитивные типы.
Начнём с более очевидной разновидности.

Параметрические составные типы

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

Так, например, можно догадаться, что из себя представляет комплексное число:

struct Complex{T<:Real} <: Number     re::T     im::T end

ci8 = Int8(1)+Int8(2)im @show typeof(ci8) sizeof(ci8)

typeof(ci8) = Complex{Int8} 2

cf64 = 1.5 + 2im @show typeof(cf64) sizeof(cf64)

typeof(cf64) = ComplexF64 16

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

То есть параметрический тип схож на шаблоны в C++.

Параметрические абстрактные типы

Примером параметрического абстрактного типа может служить AbstractDict

abstract type AbstractDict{K,V} end

Словарь же, в свою очередь является:

mutable struct Dict{K,V} <: AbstractDict{K,V}     slots::Memory{UInt8}     keys::Memory{K}     vals::Memory{V}     ...     ... end

Это нужно для того, чтобы реализовывать эффективные интерфейсы.
Например, набор переменных окруженияENV не являетсяDict, зато является AbstractDict.

При этом важно, чтобы ENV был параметрический AbstractDict{String,String}.
Поэтому параметрические абстрактные типы бывают очень удобными.

ENV isa Dict           # false ENV isa AbstractDict   # true

НАКОНЕЦ, МАССИВЫ!

И только теперь, дойдя до параметрический абстрактных типов, мы можем понять, что такое массивы.

Несмотря на то, что реализация массивов написана на C, мы можем посмотреть, что из себя представляют

[1,2,3]  [1 2 3;  4 5 6;  7 8 9;]   и rand(3,3,3)

Всё дело в определении этого типа.

   abstract type AbstractArray{T,N} end

T здесь обозначает тип переменных, который будет храниться в массиве, а N— размерность массива. (ndims просто возвращает значение N).

Array <: DenseArray <: AbstractArray # true

4-element Vector{Int8}:  0  0  0  0

Array{Int8,2}(undef,2,3)

2×3 Matrix{Int8}:  3  0  0  0  0  0

Array{Int8,3}(undef,3,3,3)

3×3×3 Array{Int8, 3}:     [:, :, 1] =      -64  24    0       36   1    0       47   0  -64          [:, :, 2] =      36  1    0      47  0  -64      24  0   36          [:, :, 3] =      47  0  -64      24  0   36       1  0   47

И вот ответ на вопрос, почему range в Julia поддерживает интерфейс массива:

1:0.5:1000 isa StepRangeLen <: AbstractArray  # true

То есть параметрический тип схож на шаблоны в C++.

Но важно понимать особенности типов в Julia

Параметрические типы в Julia являются инвариатными

DenseVector{Integer} <: DenseVector{Real}    # false DenseVector{Integer} <: DenseVector{<:Real}  # true 

 Vector{Int}     <: Vector{Real}     # false  Vector{Int}     <: Vector{<:Real}   # true  Vector{Complex} <: Vector{<:Real}   # false  Vector{Complex} <: Vector           # true

Подробнее о том, что такое Vector{<:Real} можно почитать по ссылке.

DenseVector{Integer} isa DataType # true Vector isa DataType               # false

Union{Int32,Char} isa DataType # false Vector{<:Real} isa DataType # тоже своего рода "объединение всех векторов, чей тип является подтипом Real"

И как же это всё применяется ?

Множественная диспетчеризация обладает следующим приоритетом:

1. конкретный тип,

2. абстрактный тип,

3. параметрический тип.

Закончим мы тем, что посмотрим на устройство функции наибольшего общего кратного, где есть следующие методы:

#1 function lcm(a::T, b::T) where T<:Integer #2 function lcm(x::Rational, y::Rational) #3 lcm(a::Real, b::Real) = lcm(promote(a,b)...) #4 lcm(a::T, b::T) where T<:Real = throw(MethodError(lcm, (a,b)))

1. Для случая целочисленных будет вызвана функция 1.

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

3. Если мы передадим lcm(2, 2//3),то сначала вызовется функция 3 и произойдёт продвижение типов. После чего вызовется функция 2.

promote(2, 2//3) # (2//1, 2//3)

4. Но если мы вызовем lcm(2, 1.5) , то после продвижения типов мы попадём в 4 — «шаблонную» версию, где уже будет вызвана ошибка.

До скорых встреч!