(@v1.9) pkg> help
Для получения справки по отдельной команде с примерами введите ? <имя команды> в приглашении, например:
(@v1.9) pkg> ?add
Полное руководство по менеджеру пакетов, доступно на официальном сайте https://pkgdocs.julialang.org
Актуальные и рекомендуемые сервисы для навигации по экосистеме пакетов на официальном сайте https://julialang.org/packages/
Переменные
Переменная в Julia это имя, привязанное к значению. Она используется, когда вы хотите сохранить значение (полученное, например, после математических вычислений) для последующего использования. Например:
Присвоить значение 100 переменной x
julia> x = 100
100
Выполнение математических операций со значением x
julia> x * 5
500
Переназначить значение x
julia> x = 10 + 10
20
Можно присваивать и значения других типов, например, строки текста
julia> x = "Hello World!"
"Hello World!"
Присвоение "имя = значение" привязывает переменную имени к значению, вычисленному в правой части, и все присваивание рассматривается Julia как выражение, равное значению правой части. Это означает, что присваивания можно объединять (одно и то же значение присваивается нескольким переменным переменная1 = переменная2 = значение) или использовать в других выражениях, а также то, почему их результат отображается в REPL как значение правой части. Например, здесь значение 4 из b = 2+2 используется в другой арифметической операции и присваивании:
julia> a = (b = 2 + 2) * 5
20
julia> a
20
julia> b
4
При знакомстве с переменными в Julia у новых пользователей часто возникает путаница между присвоением имени и изменением значения. Если вы выполнили a = 2, а затем a = 3, то вы изменили имя a, чтобы оно ссылалось на новое значение 3. Вы не изменили число 2, поэтому 2+2 по-прежнему дает 4, а не 6! Это различие становится более очевидным при работе с мутабельными типами данных, такими как массивы, содержимое которых может быть изменено:
julia> a=[1,2,3]
3-element Vector{Int64}:
1
2
3
julia> b=a
3-element Vector{Int64}:
1
2
3
Здесь строка b = a не создает копию массива a, а просто связывает имя b с тем же массивом: a и b "указывают" на один массив [1,2,3] в памяти.
Изменим значение первого элемента массива:
julia> a[1] = 42
42
Присваивание a[i] = value изменяет содержимое массива, измененный массив будет виден через имена a и b:
julia> a
3-element Vector{Int64}:
42
2
3
julia> b
3-element Vector{Int64}:
42
2
3
Пусть a теперь является именем другого объекта:
julia> a= 3.14159
3.14159
Установка a = 3.14159 не изменяет массив, а просто привязывает a к другому объекту, массив по-прежнему доступен через b:
julia> b
3-element Vector{Int64}:
42
2
3
Имена переменных в Julia могут быть любой длины,а также могут содержать в себе почти все символы Unicode, но не могут начинаться с цифры. В именах можно использовать прописные и строчные буквы, символ подчеркивания ('_') также может использоваться в имени переменной в любом месте. Имена переменных чувствительны к регистру.
Единственными явно запрещенными именами переменных являются имена встроенных ключевых слов: baremodule, begin, break, catch, const, continue, do, else, elseif, end, export, false, finally, for, function, global, if, import, let, local, macro, module, quote, return, struct, true, try, using, while.
Примеры допустимых и недопустимых имен:
julia> х1 = 100
100
julia> 1x=100
ERROR: syntax: "1" is not a valid function argument name around REPL[2]:1
julia> ="Точка"
"Точка"
julia> text@ = "Строка текста"
ERROR: syntax: extra token "@" after end of expression
Типы данных
По умолчанию Julia автоматически определяет какой тип данных использовать для значения переменной, но в некоторых случая, во избежании ошибок, следует указать тип данных для значений вручную.
Ниже приведен пример такой ошибки. Здесь функция typeof() возвращающая тип аргумента, а sqrt() корень квадратный из аргумента:
julia> x=-2.0
2.0
julia> typeof(x)
Float64
julia> sqrt(x)
ERROR: DomainError with -2.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Происходит следующее: Julia автоматически определяет тип значения переменной, как Float64, исходя из того, что в большинстве случаев используются действительные числа, а не комплексные, что и вызывало ошибку. Теперь тот же пример используя комплексную форму записи:
julia> x=-2.0+0im
2.0 + 0.0im
julia> typeof(x)
ComplexF64 (alias for Complex{Float64})
julia> sqrt(x)
0.0 + 1.4142135623730951im
В этом случае Julia определяет тип значения исходя из формы записи как Complex{Float64}, по сути формой записи мы задали тип значения переменной.
Типы есть только у значений. У переменных типов нет. Переменные это просто имена, связанные со значениями, хотя для простоты можно говорить "тип переменной", как сокращение от "тип значения, на которое ссылается переменная".
Julia изначально предоставляет довольно полный и иерархически организованный набор предопределенных типов, особенно числовых. Это либо скаляры, такие как: целые числа (Int), числа с плавающей запятой (Float) и символы (Char). Либо контейнероподобные структуры, способные хранить другие объекты, такие как: многомерные массивы (Array), словари (Dict), наборы (Set) и т. д. По стилистическим соглашениям названия типов начинаются с заглавной буквы, например Int64 или Bool. Иногда в фигурных скобках за именем типа следуют другие параметры, например типы содержащихся элементов или количество измерений. Эти параметры встречаются у всех контейнероподобных структур и некоторых неконтейнерных. Например тип Array{Int64,2} будет использоваться для двумерного массива целых 64-битных чисел со знаком. В терминологии Julia такие типы называются параметрическими.
Оператор :: можно использовать для присоединения аннотаций типов к выражениям и переменным в программах, например:
julia> (2+2)::Int
4
julia> (2+2)::AbstractFloat
ERROR: TypeError: in typeassert, expected AbstractFloat, got a value of type Int64
julia> (2.0+2.0)::AbstractFloat
4.0
При добавлении к выражению, вычисляющему значение, оператор :: читается как "является экземпляром". Его можно использовать в любом месте, чтобы утверждать, что значение выражения слева является экземпляром типа справа. Если тип справа конкретный, то значение слева должно иметь этот тип в качестве своей реализации. Если тип абстрактный, то достаточно, чтобы значение было реализовано конкретным типом, который является подтипом абстрактного типа. Если утверждение о типе не истинно, выбрасывается исключение, в противном случае возвращается левое значение.
Пример используемый выше, теперь нет нужды использовать комплексную форму записи:
julia> x::Complex{Float64}=-2
2
julia> typeof(x)
ComplexF64 (alias for Complex{Float64})
julia> sqrt(x)
0.0 + 1.4142135623730951im
Когда оператор :: добавляется к переменной в левой части присваивания, он означает немного другое: он объявляет переменную всегда имеющей указанный тип, как объявление типа в статически типизированном языке, таком как C. Каждое значение, присвоенное переменной, будет преобразовано к объявленному типу с помощью функции convert(), если это возможно.
Целые числа
Типы целых чисел в Julia:
Целые числа вводятся и выводятся стандартным образом:
julia> 10
10
julia> 0123456789
123456789
Тип по умолчанию для целых чисел зависит от разрядности системы (64-бита):
julia> typeof(10)
Int64
julia> typeof(0123456789)
Int64
Julia также определяет типы Int и UInt, которые являются псевдонимами для системных знаковых и беззнаковых типов целых чисел соответственно:
julia> Int
Int64
julia> UInt
UInt64
Большие целые числа, которые не могут быть представлены с использованием 64 бит, но могут быть представлены в 128 битах, всегда создают 128-битные целые числа, независимо от типа системы:
julia> typeof(10000000000000000000)
Int128
Беззнаковые целые числа
Беззнаковые целые числа вводятся и выводятся с использованием префикса 0x и цифр от 0 до 9, а также латинских букв от a до f, используемых для обозначения шестнадцатеричных чисел, использование заглавных букв A-F также допустимо. Размер беззнакового значения определяется количеством используемых шестнадцатеричных цифр:
julia> x = 0x1
0x01
julia> typeof(x)
UInt8
julia> x = 0x123
0x0123
julia> typeof(x)
UInt16
julia> x = 0x1234567
0x01234567
julia> typeof(x)
UInt32
julia> x = 0x123456789abcdef
0x0123456789abcdef
julia> typeof(x)
UInt64
julia> x = 0x11112222333344445555666677778888
0x11112222333344445555666677778888
julia> typeof(x)
UInt128
Значения, слишком большие для типов Int128, UInt128, при вводе получат специальный тип BigInt:
julia> typeof(100000000000000000000000000000000000000)
Int128
julia> typeof(1000000000000000000000000000000000000000)
BigInt
julia> typeof(0xffffffffffffffffffffffffffffffff)
UInt128
julia> typeof(0xfffffffffffffffffffffffffffffffff)
BigInt
Это не беззнаковый тип, но это единственный встроенный тип, достаточно большой для представления таких больших целых значений.
Поведение при переполнении
В Julia превышение максимального представляемого значения данного типа приводит к циклическому поведению. Пример (функции typemax(), typemin(), возвращают максимальное и минимальное значения для заданного типа, == оператор равенства):
julia> x = typemax(Int64)
9223372036854775807
julia> x+1
9223372036854775808
julia> x + 1 == typemin(Int64)
true
julia> x = typemax(UInt64)
0xffffffffffffffff
julia> x+1
0x0000000000000000
julia> x + 1 == typemin(UInt64)
true
В тех случаях, когда переполнение возможно, рекомендуется производить проверку на цикличное поведение. В противном случае используйте тип BigInt арифметики произвольной точности. Ниже приведен пример поведения при переполнении и как его можно решить с помощью BigInt():
julia> 10^19
8446744073709551616
julia> BigInt(10)^19
10000000000000000000
Числа с плавающей точкой
Типы чисел с плавающей точкой в Julia:
Числа с плавающей точкой вводятся и выводятся стандартным образом:
julia> 1.0
1.0
julia> 1.
1.0
julia> 0.5
0.5
julia> .5
0.5
julia> -1.23
1.23
При необходимости можно использовать E-нотацию:
julia> 1e10
1.0e10
julia> 2.5e-4
0.00025
Все результаты из примеров выше имеют тип Float64 (тип по умолчанию). Если вы хотите ввести значение с типом Float32, то необходимо использовать f вместо e следующим образом:
julia> x = 0.5f0
0.5f0
julia> typeof(x)
Float32
julia> 2.5f-4
0.00025f0
Значение с типом Float16:
julia> Float16(4.)
Float16(4.0)
julia> 2*Float16(4.)
Float16(8.0)
Ноль с плавающей точкой
Числа с плавающей точкой имеют два нуля положительный нуль и отрицательный нуль. Они равны друг другу, но имеют разные двоичные представления, что можно увидеть с помощью функции bitstring(), которая дает буквальное битовое представление примитивного типа:
julia> 0.0 == -0.0
true
julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"
julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"
Когда точности или размерности Float64 недостаточно, можно использовать специальный тип BigFloat:
julia> 2.0^100/4
3.1691265005705735e29
julia> BigFloat(2.0)^100/4
3.16912650057057350374175801344e+29
BigFloat знаковый тип арифметики произвольной точности, не назначаемый автоматически при вводе, а требующий явного объявления для использования.
Функции минимального и максимального значений для типов также применимы:
julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)
julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)
julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)
Результатом будут специальные значения отрицательная и положительная бесконечности. Значения чисел превышающих числовой диапазон типа также будут заменены на специальные значения:
julia> 4.2^1000
Inf
julia> -4.2^1000
Inf
Специальные значения
Существует три определенных стандартных значения с плавающей точкой, которые не соответствуют ни одной точке на линии вещественных чисел:
По стандарту IEEE 754, эти значения с плавающей точкой являются результатами определенных арифметических операций:
julia> 1/0
Inf
julia> -5/0
Inf
julia> 0.000001/0
Inf
julia> 0/0
NaN
julia> 1/Inf
0.0
julia> 1/-Inf
0.0
julia> -1/Inf
0.0
julia> -1/-Inf
0.0
julia> 500 + Inf
Inf
julia> 500 Inf
Inf
julia> Inf + Inf
Inf
julia> -Inf -Inf
Inf
julia> Inf Inf
NaN
julia> Inf * Inf
Inf
julia> Inf*-Inf
Inf
julia> -Inf * -Inf
Inf
julia> Inf / Inf
NaN
julia> Inf /-Inf
NaN
julia> -Inf /Inf
NaN
julia> -Inf /-Inf
NaN
julia> 0 * Inf
NaN
julia> 0 *-Inf
NaN
Тип NaN
NaN не равно, не меньше и не больше чего-либо, включая самого себя:
julia> NaN == NaN
false
julia> NaN != NaN
true
julia> NaN < NaN
false
julia> NaN > NaN
false
Это может вызвать проблемы, например при работе с массивами:
julia> [1 NaN] == [1 NaN]
false
Функции Julia для работы со специальными значениями:
Функция isequal() считает NaNs равными друг другу:
julia> isequal(NaN, NaN)
true
julia> isequal([1 NaN], [1 NaN])
true
julia> isequal(NaN, NaN32)
true
Функцию isequal() можно также использовать для различения знаковых нулей:
julia> -0.0 == 0.0
true
julia> isequal(-0.0, 0.0)
false
Машинный эпсилон
Большинство реальных чисел не могут быть точно представлены числами с плавающей точкой, поэтому для многих целей важно знать расстояние между двумя соседними представляемыми числами с плавающей точкой, которое часто называют машинным эпсилоном.
Функция eps() в Julia дает расстояние между 1.0 и следующим большим значением с плавающей точкой, при использовании в качестве аргумента типа числа с плавающей точкой: