Основные принципы

Введение

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

Некоторые общие замечания:

• За исключением функций встроенных модулей (Pkg, Collections, Test и Profile), все функции, документированные здесь, напрямую доступны для использования в программах.

• Для использования функций модуля используйте import Module для импорта модуля и Module.fn(x) для использования функций.

• В качестве альтернативы, using Module импортирует все экспортированные Module функции в текущее пространство имен.

• По соглашению, имена функций, оканчивающиеся на восклицательный знак (!), изменяют свои аргументы. Некоторые функции имеют как изменяющие (например, sort!) версии, так и неизменяющие (sort) версии.

Перемещение

Base.exitФункция

exit([code])

Выход (или сочетание клавиш Ctrl+D в командной строке). Значение кода выхода по умолчанию равно нулю, что указывает на успешное завершение процессов.

Base.quitФункция

quit()

Завершение программы, указывая на успешное завершение процессов. Эта функция вызывает exit(0) (см. exit).

Base.atexitФункция

atexit(f)

Регистрация функции с нулевыми аргументами f() для вызова при завершении процесса. atexit() обработчики вызываются в порядке LIFO (последний вошел, первый вышел) и выполняются перед финализаторами объектов.

Base.atreplinitФункция

atreplinit(f)

Регистрация функции с одним аргументом для вызова перед инициализацией интерфейса REPL в интерактивных сеансах; это полезно для настройки интерфейса. Аргумент функции f — объект REPL. Эта функция должна вызываться из файла инициализации .juliarc.jl.

Base.isinteractiveФункция

isinteractive() -> Bool

Определение, работает ли Julia в интерактивном сеансе.

Base.whosФункция

whos(io::IO=STDOUT, m::Module=current_module(), pattern::Regex=r"")

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

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

Base.summarysizeФункция

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

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

Ключевые аргументы

• exclude: определяет типы объектов, которые следует исключить из обхода.

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

Base.editМетод

edit(path::AbstractString, line::Integer=0)

Редактирование файла или каталога, необязательно указав номер строки для редактирования в файле. Возвращение к приглашению julia при выходе из редактора. Редактор может быть изменён путём установки JULIA_EDITOR, VISUAL или EDITOR в качестве переменной окружения.

Base.editМетод

edit(function, [types])

Редактирование определения функции, необязательно указав кортеж типов для указания метода, который нужно редактировать. Редактор может быть изменен, установив JULIA_EDITOR, VISUAL или EDITOR в качестве переменной окружения.

Base.@editМакрос

@edit

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

Base.lessМетод

less(file::AbstractString, [line::Integer])

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

Base.lessМетод

less(function, [types])

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

Base.@lessМакрос

@less

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

Base.clipboardМетод

clipboard(x)

Отправка отформатированного представления x в буфер обмена операционной системы («копировать»).

Base.clipboardМетод

clipboard() -> AbstractString

Возвращение строки с содержимым буфера обмена операционной системы («вставить»).

Base.reloadФункция

reload(name::AbstractString)

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

Base.requireФункция

require(module::Symbol)

Эта функция входит в реализацию using / import, если модуль ещё не определён в Main. Также её можно вызвать напрямую для принудительной перезагрузки модуля, независимо от того, был ли он загружен ранее (например, при интерактивном разработке библиотек).

Загрузка исходного файла в контексте модуля Main на каждом активном узле, поиск файлов в стандартных расположениях. require рассматривается как операция верхнего уровня, поэтому она устанавливает текущий include путь, но не использует его для поиска файлов (см. справку по include). Эта функция обычно используется для загрузки кода библиотек и неявно вызывается using для загрузки пакетов.

При поиске файлов require сначала ищет код пакета в Pkg.dir(), затем пытается использовать пути в глобальном массиве LOAD_PATH. require чувствителен к регистру на всех платформах, включая те, где файловая система нечувствительна к регистру, такие как macOS и Windows.

Base.compilecacheФункция

Base.compilecache(module::String)

Создает файл предварительно скомпилированного кэша для модуля и всех его зависимостей. Это может быть использовано для уменьшения времени загрузки пакетов. Файлы кэша хранятся в LOAD_CACHE_PATH[1], по умолчанию это ~/.julia/lib/VERSION. См. Инициализация и предварительная компиляция модулей для важных примечаний.

Base.__precompile__Функция

__precompile__(isprecompilable::Bool=true)

Укажите, является ли файл, вызывающий эту функцию, предварительно компилируемым. Если isprecompilable является true, то __precompile__ выбрасывает исключение при загрузке файла using/import/require если файл не предварительно компилируется, а в файле модуля это приводит к автоматической предварительной компиляции модуля при его импорте. Как правило, __precompile__() должно выполняться до объявления module в файле, или ещё лучше VERSION >= v"0.4" && __precompile__(), чтобы обеспечить обратную совместимость с Julia 0.3.

Если модуль или файл не являются безопасно предварительно компилируемыми, он должен вызвать __precompile__(false) для того, чтобы сгенерировать ошибку, если Julia попытается его предварительно скомпилировать.

__precompile__() не должно использоваться в модуле, если все его зависимости также не используют __precompile__(). Отсутствие этого может привести к ошибке во время выполнения при загрузке модуля.

Base.includeФункция

include(path::AbstractString)

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

Base.include_stringФункция

include_string(code::AbstractString, filename::AbstractString="string")

Аналогично include, но считывает код из заданной строки, а не из файла. Поскольку путь к файлу не участвует, обработка пути и загрузка с узла 1 не выполняются.

Base.include_dependencyФункция

include_dependency(path::AbstractString)

В модуле объявляется, что файл, указанный в path (относительный или абсолютный), является зависимостью для предварительной компиляции; то есть, модуль потребуется перекомпилировать, если этот файл изменится.

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

Base.Docs.aproposФункция

apropos(string)

Ищет в документации строку, игнорируя регистр.

Base.whichМетод

which(f, types)

Возвращает метод f (объект типа Method), который будет вызван для аргументов заданного типа types.

Если types является абстрактным типом, то возвращается метод, который будет вызван invoke.

Base.whichМетод

which(symbol)

Возвращает модуль, в котором было создано связывание для переменной, на которую ссылается symbol.

Base.@whichМакрос

@which

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

Base.methodsФункция

methods(f, [types])

Возвращает таблицу методов для f.

Если types указано, возвращает массив методов, типы которых соответствуют.

Base.methodswithФункция

methodswith(typ[, module or function][, showparents::Bool=false])

Возвращает массив методов с аргументом типа typ.

Дополнительный второй аргумент ограничивает поиск определённым модулем или функцией (по умолчанию все модули, начиная с Main).

Если необязательный showparents равен true, то также возвращает аргументы с родительским типом typ, исключая тип Any.

Base.@showМакрос

@show

Отображает выражение и результат, возвращая результат.

Base.versioninfoФункция

versioninfo(io::IO=STDOUT, verbose::Bool=false)

Выводит информацию о версии используемой Julia. Если аргумент verbose равен true, то также отображается подробная информация о системе.

Base.workspaceФункция

workspace()

Заменяет основной модуль (Main) новым, предоставляя чистую рабочую область. Предыдущий модуль Main становится доступным как LastMain. Ранее загруженный пакет можно получить, используя выражение, например using LastMain.Package.

Эта функция должна использоваться только интерактивно.

ansКлючевое слово

ans

Переменная, ссылающаяся на последнее вычисленное значение, автоматически устанавливаемое в интерактивном режиме.

Все объекты

Core.:===Функция

===(x,y) -> Bool
≡(x,y) -> Bool

Определяет, являются ли x и y идентичными в том смысле, что никакая программа не сможет их различить. Сравнивает изменяемые объекты по адресу в памяти, а неизменяемые объекты (например, числа) сравнивает по содержимому на битовом уровне. Иногда эта функция называется egal.

julia> a = [1, 2]; b = [1, 2];

julia> a == b
true

julia> a === b
false

julia> a === a
true

Core.isaФункция

isa(x, type) -> Bool

Определяет, относится ли x к заданному типу type. Также может использоваться как инфиксный оператор, например, x isa type.

Base.isequalМетод

isequal(x, y)

Аналогично ==, но обрабатывает все значения с плавающей точкой NaN как равные друг другу и считает -0.0 не равными 0.0. По умолчанию isequal вызывает ==, поэтому, если у вас есть тип, не имеющий этих особенностей с плавающей точкой, вам, вероятно, нужно только определить ==.

isequal — это функция сравнения, используемая хеш-таблицами (Dict). isequal(x,y) должно подразумевать, что hash(x) == hash(y).

Это обычно означает, что если вы определяете собственную функцию ==, то вы должны определить соответствующую функцию hash (и наоборот). Коллекции обычно реализуют isequal путём рекурсивного вызова isequal на всех элементах.

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

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

Base.isequalМетод

isequal(x, y)

Аналогично ==, но обрабатывает все значения с плавающей точкой NaN как равные друг другу и считает -0.0 не равными 0.0.

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

isequal — это функция сравнения, используемая хеш-таблицами (Dict). isequal(x,y) должно подразумевать, что hash(x) == hash(y).

Это обычно означает, что если вы определите свою собственную == функцию, то вы должны определить соответствующую hash (и наоборот). Коллекции обычно реализуют isequal, вызывая isequal рекурсивно для всех содержимых.

Скалярные типы, как правило, не нуждаются в реализации isequal отдельно от ==, если только они не представляют числа с плавающей запятой, для которых возможна более эффективная реализация, чем та, которая предоставляется как общий резервный вариант (основанная на isnan, signbit, и ==).

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

isequal(x::Nullable, y::Nullable)

Если ни x, ни y не равны null, сравните их по значениям (т.е. isequal(get(x), get(y))). В противном случае верните true, если оба аргумента равны null, и false, если один из них равен null, а другой — нет: null считаются равными.

Base.islessФункция

isless(x, y)

Проверить, является ли x меньше y, согласно каноническому полному порядку. Значения, которые обычно не упорядочены, такие как NaN, упорядочиваются произвольным, но согласованным способом. Это по умолчанию используется для сравнения в sort. Типы, не являющиеся числовыми, но имеющие канонический полный порядок, должны реализовывать эту функцию. Числовые типы должны реализовывать её только если у них есть особые значения, такие как NaN.

Base.islessМетод

isless(x::Nullable, y::Nullable)

Если ни x, ни y не равны null, сравните их по значениям (т.е. isless(get(x), get(y))). В противном случае верните true, если только y равно null, и false в противном случае: null всегда считаются больше, чем не-null, но не больше другого null.

Base.ifelseФункция

ifelse(condition::Bool, x, y)

Вернуть x, если condition равно true, в противном случае вернуть y. Это отличается от ? или if, поскольку это обычная функция, поэтому все аргументы оцениваются сначала. В некоторых случаях использование ifelse вместо оператора if может устранить ветвление в сгенерированном коде и обеспечить более высокую производительность в узких циклах.

julia> ifelse(1 > 2, 1, 2)
2

Base.lexcmpФункция

lexcmp(x, y)

Сравнить x и y лексикографически и вернуть -1, 0 или 1 в зависимости от того, меньше ли x чем, равно ли, или больше ли чем y, соответственно. Эта функция должна быть определена для лексикографически сравнимых типов, и lexless будет вызывать lexcmp по умолчанию.

julia> lexcmp("abc", "abd")
-1

julia> lexcmp("abc", "abc")
0

Base.lexlessФункция

lexless(x, y)

Определить, меньше ли x лексикографически, чем y.

julia> lexless("abc", "abd")
true

Core.typeofФункция

typeof(x)

Получить конкретный тип x.

Core.tupleФункция

tuple(xs...)

Создать кортеж из указанных объектов.

Пример

julia> tuple(1, 'a', pi)
(1, 'a', π = 3.1415926535897...)

Base.ntupleФункция

ntuple(f::Function, n::Integer)

Создать кортеж длины n, вычисляя каждый элемент как f(i), где i — индекс элемента.

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)

Base.object_idФункция

object_id(x)

Получить значение хэша для x на основе идентификатора объекта. object_id(x)==object_id(y), если x === y.

Base.hashФункция

hash(x[, h::UInt])

Вычислить целочисленное значение хэша таким образом, что isequal(x,y) подразумевает hash(x)==hash(y). Дополнительный второй аргумент h — это значение хэша, которое будет смешиваться с результатом.

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

Base.finalizerФункция

finalizer(x, f)

Зарегистрировать функцию f(x) для вызова, когда нет доступных в программе ссылок на x. Тип x должен быть mutable struct, в противном случае поведение этой функции будет непредсказуемым.

Base.finalizeФункция

finalize(x)

Немедленно выполнить финализаторы, зарегистрированные для объекта x.

Base.copyФункция

copy(x)

Создать поверхностную копию x: копируется внешняя структура, но не все внутренние значения. Например, копирование массива создаёт новый массив с идентичными элементами, как в оригинале.

Base.deepcopyФункция

deepcopy(x)

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

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

Хотя это обычно не требуется, пользовательские типы могут переопределить поведение по умолчанию deepcopy путём определения специализированной версии функции deepcopy_internal(x::T, dict::ObjectIdDict) (которую в противном случае не следует использовать), где T — тип для специализации, и dict отслеживает уже скопированные объекты внутри рекурсии. Внутри определения deepcopy_internal следует использовать вместо deepcopy, а переменная dict должна быть обновлена соответствующим образом перед возвратом.

Core.isdefinedФункция

isdefined([m::Module,] s::Symbol)
isdefined(object, s::Symbol)
isdefined(object, index::Int)

Проверяет, определена ли присваиваемая область. Аргументами могут быть модуль и символ или составной объект и имя поля (в виде символа) или индекс. С одним аргументом-символом проверяет, определена ли в current_module() глобальная переменная с этим именем.

Base.convertФункция

convert(T, x)

Преобразовать x в значение типа T.

Если T — тип Integer, ошибка InexactError будет поднята, если x не может быть представлен типом T, например, если x не является целым числом или выходит за пределы диапазона, поддерживаемого T.

Примеры

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError()
Stacktrace:
 [1] convert(::Type{Int64}, ::Float64) at ./float.jl:679

Если T — это тип AbstractFloat или Rational, то он вернёт значение, наиболее близкое к x и представимое в T.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(Rational{Int32}, x)
1//3

julia> convert(Rational{Int64}, x)
6004799503160661//18014398509481984

Если T — это тип коллекции, а x — коллекция, то результат convert(T, x) может ссылаться на x.

julia> x = Int[1,2,3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

Аналогично, если T — это составной тип, а x — связанный экземпляр, результат convert(T, x) может ссылаться на часть или весь x.

julia> x = speye(5);

julia> typeof(x)
SparseMatrixCSC{Float64,Int64}

julia> y = convert(SparseMatrixCSC{Float64,Int64}, x);

julia> z = convert(SparseMatrixCSC{Float32,Int64}, y);

julia> y === x
true

julia> z === x
false

julia> z.colptr === x.colptr
true

Base.promoteФункция

promote(xs...)

Преобразовать все аргументы к общему типу повышения (если таковой существует) и вернуть их все (в виде кортежа).

Пример

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

Base.oftypeФункция

oftype(x, y)

Преобразовать y к типу x (convert(typeof(x), y)).

Base.widenФункция

widen(x)

Если x — это тип, вернуть «более широкий» тип (для числовых типов это будет тип с не меньшим диапазоном и точностью, чем аргумент, и обычно с большим). В противном случае x преобразуется в widen(typeof(x)).

Примеры

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

Base.identityФункция

identity(x)

Функция тождества. Возвращает свой аргумент.

julia> identity("Well, what did you expect?")
"Well, what did you expect?"

Типы

Base.supertypeФункция

supertype(T::DataType)

Возвращает супертип типа данных T.

julia> supertype(Int32)
Signed

Core.issubtypeФункция

issubtype(type1, type2)

Возвращает true тогда и только тогда, когда все значения type1 также являются значениями типа type2. Также может быть записано с помощью инфиксного оператора <: как type1 <: type2.

Примеры

julia> issubtype(Int8, Int32)
false

julia> Int8 <: Integer
true

Base.:<:Функция

<:(T1, T2)

Оператор подтипа, эквивалентный issubtype(T1, T2).

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false

Base.:>:Функция

>:(T1, T2)

Оператор супертипа, эквивалентный issubtype(T2, T1).

Base.subtypesФункция

subtypes(T::DataType)

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

julia> subtypes(Integer)
4-element Array{Union{DataType, UnionAll},1}:
 BigInt
 Bool
 Signed
 Unsigned

Base.typeminФункция

typemin(T)

Наименьшее значение, представимое заданным (вещественным) числовым типом данных T.

Примеры

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

Base.typemaxФункция

typemax(T)

Наибольшее значение, представимое заданным (вещественным) числовым типом DataType.

Base.realminФункция

realmin(T)

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

Base.realmaxФункция

realmax(T)

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

Примеры

julia> realmax(Float16)
Float16(6.55e4)

julia> realmax(Float32)
3.4028235f38

Base.maxintfloatФункция

maxintfloat(T)

Наибольшее целое число, без потерь представимое заданным типом с плавающей точкой T.

maxintfloat(T, S)

Наибольшее целое число, без потерь представимое заданным типом с плавающей точкой T и не превосходящее максимальное целое число, представимое заданным целочисленным типом S.

Base.sizeofМетод

sizeof(T)

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

Примеры

julia> sizeof(Float32)
4

julia> sizeof(Complex128)
16

Если у T нет определённого размера, выбрасывается ошибка.

julia> sizeof(Base.LinAlg.LU)
ERROR: argument is an abstract type; size is indeterminate
Stacktrace:
 [1] sizeof(::Type{T} where T) at ./essentials.jl:159

Base.epsМетод

eps(::Type{T}) where T<:AbstractFloat
eps()

Возвращает машинную эпсилон типа с плавающей точкой T (по умолчанию T = Float64). Это определяется как разрыв между 1 и следующим большим значением, представимым T, и эквивалентно eps(one(T)).

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

Base.epsМетод

eps(x::AbstractFloat)

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

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

Исключения из этого правила — наименьшее и наибольшее конечные значения (например, nextfloat(-Inf) и prevfloat(Inf) для Float64), которые округляются до меньшего из значений.

Обоснование этого поведения заключается в том, что eps ограничивает ошибку округления с плавающей точкой. При стандартном режиме округления, если $y$ — вещественное число, а $x$ — ближайшее число с плавающей точкой к $y$, то

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # largest finite Float64
1.7976931348623157e308

julia> x + eps(x)/2            # rounds up
Inf

julia> x + prevfloat(eps(x)/2) # rounds down
1.7976931348623157e308

Base.promote_typeФункция

promote_type(type1, type2)

Определить тип, достаточно большой, чтобы содержать значения каждого типа аргумента без потерь, когда это возможно. В некоторых случаях, когда такого типа не существует, для которого оба типа могут быть повышены без потерь, допускается небольшая потеря; например, promote_type(Int64, Float64) возвращает Float64, даже если строго говоря, не все значения Int64 могут быть представлены точно как значения Float64.

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

Base.promote_ruleФункция

promote_rule(type1, type2)

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

Core.getfieldФункция

getfield(value, name::Symbol)

Извлеките именованное поле из value составного типа. Синтаксис a.b вызывает getfield(a, :b).

Пример

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

Core.setfield!Функция

setfield!(value, name::Symbol, x)

Присвойте x именованному полю в value составного типа. Синтаксис a.b = c вызывает setfield!(a, :b, c).

Base.fieldoffsetФункция

fieldoffset(type, i)

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

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:nfields(T)];

julia> structinfo(Base.Filesystem.StatStruct)
12-element Array{Tuple{UInt64,Symbol,DataType},1}:
 (0x0000000000000000, :device, UInt64)
 (0x0000000000000008, :inode, UInt64)
 (0x0000000000000010, :mode, UInt64)
 (0x0000000000000018, :nlink, Int64)
 (0x0000000000000020, :uid, UInt64)
 (0x0000000000000028, :gid, UInt64)
 (0x0000000000000030, :rdev, UInt64)
 (0x0000000000000038, :size, Int64)
 (0x0000000000000040, :blksize, Int64)
 (0x0000000000000048, :blocks, Int64)
 (0x0000000000000050, :mtime, Float64)
 (0x0000000000000058, :ctime, Float64)

Core.fieldtypeФункция

fieldtype(T, name::Symbol | index::Int)

Определите объявленный тип поля (указанного по имени или индексу) в составном типе данных T.

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

Base.isimmutableФункция

isimmutable(v)

Возвращает true если значение v неизменяемое. См. Мутируемые составные типы для обсуждения неизменяемости. Обратите внимание, что эта функция работает со значениями, поэтому, если вы передадите тип, она сообщит вам, что значение типа DataType изменяемо.

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

Base.isbitsФункция

isbits(T)

Возвращает true если T является типом «простых данных», то есть неизменяемым и не содержит ссылок на другие значения. Типичными примерами являются числовые типы, такие как UInt8, Float64 и Complex{Float64}.

julia> isbits(Complex{Float64})
true

julia> isbits(Complex)
false

Base.isleaftypeФункция

isleaftype(T)

Определите, являются ли единственными подтипами T самим собой и Union{}. Это означает, что T является конкретным типом, который может иметь экземпляры.

julia> isleaftype(Complex)
false

julia> isleaftype(Complex{Float32})
true

julia> isleaftype(Vector{Complex})
true

julia> isleaftype(Vector{Complex{Float32}})
true

Base.typejoinФункция

typejoin(T, S)

Вычислите тип, содержащий как T так и S.

Base.typeintersectФункция

typeintersect(T, S)

Вычислите тип, содержащий пересечение T и S. Обычно это будет наименьший такой тип или близкий к нему.

Base.ValТип

Val{c}

Создайте «тип значения» из c, который должен быть значением isbits. Цель этого конструкта — возможность диспетчеризации по константам, например, f(Val{false}) позволяет напрямую (во время компиляции) диспетчеризировать к реализации f(::Type{Val{false}}), без необходимости проверки булевого значения во время выполнения.

Base.Enums.@enumМакрос

@enum EnumName[::BaseType] value1[=x] value2[=y]

Создайте подтип Enum{BaseType} с именем EnumName и значениями членов перечисления value1 и value2 с необязательными присвоенными значениями x и y соответственно. EnumName может использоваться как другие типы, а значения членов перечисления — как обычные значения, такие как

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "I'm a Fruit with value: $(Int(x))"
f (generic function with 1 method)

julia> f(apple)
"I'm a Fruit with value: 1"

BaseType, по умолчанию Int32, должен быть примитивным подтипом Integer. Значения членов можно преобразовывать между типом перечисления и BaseType. read и write выполняют эти преобразования автоматически.

Base.instancesФункция

instances(T::Type)

Возвращает коллекцию всех экземпляров данного типа, если применимо. В основном используется для перечислений (см. @enum).

julia> @enum Color red blue green

julia> instances(Color)
(red::Color = 0, blue::Color = 1, green::Color = 2)

Общие функции

Core.FunctionТип

Function

Абстрактный тип всех функций.

julia> isa(+, Function)
true

julia> typeof(sin)
Base.#sin

julia> ans <: Function
true

Base.method_existsФункция

method_exists(f, Tuple type, world=typemax(UInt)) -> Bool

Определяет, имеет ли данная общая функция метод, соответствующий заданному Tuple типов аргументов с верхней границей возраста мира, заданной world.

julia> method_exists(length, Tuple{Array})
true

Core.applicableФункция

applicable(f, args...) -> Bool

Определяет, имеет ли данная общая функция метод, применимый к заданным аргументам.

Примеры

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Core.invokeФункция

invoke(f, types <: Tuple, args...)

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

Base.invokelatestФункция

invokelatest(f, args...)

Вызывает f(args...), но гарантирует, что будет выполнен наиболее новый метод f. Это полезно в специализированных ситуациях, например, в долговременных циклах событий или функциях обратного вызова, которые могут вызывать устаревшие версии функции f. (Недостатком является то, что invokelatest несколько медленнее, чем прямой вызов f, и тип результата не может быть выведен компилятором.)

Base.:|>Функция

|>(x, f)

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

julia> [1:5;] |> x->x.^2 |> sum |> inv
0.01818181818181818

Base.:∘Функция

f ∘ g

Компонует функции: т.е. (f ∘ g)(args...) означает f(g(args...)) . Символ ∘ можно ввести в интерактивном режиме Julia (и в большинстве редакторов, соответствующим образом настроенных) набрав \circ<tab>. Пример:

julia> map(uppercase∘hex, 250:255)
6-element Array{String,1}:
 "FA"
 "FB"
 "FC"
 "FD"
 "FE"
 "FF"

Синтаксис

Core.evalФункция

eval([m::Module], expr::Expr)

Вычисляет выражение в заданном модуле и возвращает результат. У каждого Module (кроме определённых с baremodule) есть собственное одноаргументное определение eval, которое вычисляет выражения в этом модуле.

Base.@evalМакрос

@eval [mod,] ex

Вычисляет выражение с внедрёнными в него значениями, используя eval . Если предоставлено два аргумента, первым является модуль для вычисления.

Base.evalfileФункция

evalfile(path::AbstractString, args::Vector{String}=String[])

Загрузить файл с помощью include, вычислить все выражения и вернуть значение последнего.

Base.escФункция

esc(e::ANY)

Действует только в контексте Expr возвращённого макросом. Предотвращает преобразование встроенных переменных в переменные gensym при проходе макросной гигиены. Подробнее и примеры см. в разделе «Макросы» главы «Метапрограммирование» руководства.

Base.@inboundsМакрос

@inbounds(blk)

Исключает проверку границ массива в выражениях.

В примере ниже проверка границ массива A пропущена для повышения производительности.

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i = 1:length(A)
        @inbounds r += A[i]
    end
    return r
end

Base.@inlineМакрос

@inline

Подсказка компилятору, что данную функцию стоит встроить.

Для небольших функций аннотация @inline обычно не нужна, так как компилятор делает это автоматически. Использование @inline для больших функций может помочь компилятору встроить её. Пример:

@inline function bigfunction(x)
    #=
        Function Definition
    =#
end

Base.@noinlineМакрос

@noinline

Предотвращает встраивание функции компилятором.

Маленькие функции обычно встраиваются автоматически. Использование @noinline для маленьких функций может предотвратить их автоматическое встраивание. Пример:

@noinline function smallfunction(x)
    #=
        Function Definition
    =#
end

Base.gensymФункция

gensym([tag])

Генерирует символ, который не будет конфликтовать с другими именами переменных.

Base.@gensymМакрос

@gensym

Генерирует символ gensym для переменной. Например, @gensym x y преобразуется в x = gensym("x"); y = gensym("y").

Base.@pollyМакрос

@polly

Указывает компилятору применить полиэдральный оптимизатор Polly к функции.

Base.parseМетод

parse(str, start; greedy=true, raise=true)

Разбирает строку выражения и возвращает выражение (которое можно передать в eval для выполнения). start — индекс первого символа для начала разбора. Если greedy равен true (по умолчанию), parse попытается прочитать как можно больше входных данных; в противном случае, он остановится, как только будет разобрано корректное выражение. Неполные, но синтаксически корректные выражения вернут Expr(:incomplete, "(error message)"). Если raise равно true (по умолчанию), синтаксические ошибки, кроме неполных выражений, вызовут ошибку. Если raise равно false, parse вернёт выражение, которое при вычислении вызовет ошибку.

julia> parse("x = 3, y = 5", 7)
(:(y = 5), 13)

julia> parse("x = 3, y = 5", 5)
(:((3, y) = 5), 13)

Base.parseМетод

parse(str; raise=true)

Жадно разбирает строку выражения, возвращая единственное выражение. Если после первого выражения есть дополнительные символы, возникает ошибка. Если raise равно true (по умолчанию), синтаксические ошибки вызывают ошибку; в противном случае, parse вернёт выражение, которое при вычислении вызовет ошибку.

julia> parse("x = 3")
:(x = 3)

julia> parse("x = ")
:($(Expr(:incomplete, "incomplete: premature end of input")))

julia> parse("1.0.2")
ERROR: ParseError("invalid numeric constant \"1.0.\"")
Stacktrace:
[...]

julia> parse("1.0.2"; raise = false)
:($(Expr(:error, "invalid numeric constant \"1.0.\"")))

Nullables

Base.NullableТип

Nullable(x, hasvalue::Bool=true)

Обёртка значения x в объект типа Nullable, указывающий на наличие значения. Nullable(x) создаёт непустую обёртку, а Nullable{T}() — пустой экземпляр обёртки, которая может содержать значение типа T.

Nullable(x, false) возвращает Nullable{typeof(x)}(), где x сохраняется в поле value результата.

Примеры

julia> Nullable(1)
Nullable{Int64}(1)

julia> Nullable{Int64}()
Nullable{Int64}()

julia> Nullable(1, false)
Nullable{Int64}()

julia> dump(Nullable(1, false))
Nullable{Int64}
  hasvalue: Bool false
  value: Int64 1

Base.getМетод

get(x::Nullable[, y])

Попытка получить значение x. Возвращает значение, если оно есть; иначе, возвращает y (если предоставлено) или вызывает NullException (если не предоставлено).

Base.isnullФункция

isnull(x)

Возвращает, является ли x нулевым для Nullable x; возвращает false для всех остальных x.

Примеры

julia> x = Nullable(1, false)
Nullable{Int64}()

julia> isnull(x)
true

julia> x = Nullable(1, true)
Nullable{Int64}(1)

julia> isnull(x)
false

julia> x = 1
1

julia> isnull(x)
false

Base.unsafe_getФункция

unsafe_get(x)

Возвращает значение x для Nullable x; возвращает x для всех остальных x.

Этот метод не проверяет, является ли x нулевым, прежде чем пытаться получить значение x для x::Nullable (отсюда «unsafe»).

julia> x = Nullable(1)
Nullable{Int64}(1)

julia> unsafe_get(x)
1

julia> x = Nullable{String}()
Nullable{String}()

julia> unsafe_get(x)
ERROR: UndefRefError: access to undefined reference
Stacktrace:
 [1] unsafe_get(::Nullable{String}) at ./nullable.jl:125

julia> x = 1
1

julia> unsafe_get(x)
1

Система

Base.runФункция

run(command, args...)

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

Base.spawnФункция

spawn(command)

Асинхронно выполняет команду, возвращая объект Process.

Base.DevNullКонстанта

DevNull

Используется для перенаправления потока, чтобы игнорировать все данные, записанные в него. По сути, эквивалентно /dev/null в Unix или NUL в Windows. Пример использования:

run(pipeline(`cat test.txt`, DevNull))

Base.successФункция

success(command)

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

Base.process_runningФункция

process_running(p::Process)

Определяет, запущен ли процесс в данный момент.

Base.process_exitedФункция

process_exited(p::Process)

Определяет, завершил ли процесс свою работу.

Base.killМетод

kill(p::Process, signum=SIGTERM)

Отправляет сигнал процессу. По умолчанию процесс завершается.

Base.Sys.set_process_titleФункция

Sys.set_process_title(title::AbstractString)

Устанавливает заголовок процесса. Может быть не реализовано на некоторых операционных системах.

Base.Sys.get_process_titleФункция

Sys.get_process_title()

Получить заголовок процесса. В некоторых системах всегда возвращает пустую строку.

Base.readandwriteФункция

readandwrite(command)

Запускает команду асинхронно и возвращает кортеж (stdout, stdin, процесс) из потока вывода, потока ввода процесса и самого объекта процесса.

Base.ignorestatusФункция

ignorestatus(command)

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

Base.detachФункция

detach(command)

Помечает объект команды так, что он будет выполняться в новой группе процессов, что позволит ему пережить процесс Julia и не получать прерывания Ctrl-C.

Base.CmdТип

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)

Создать новый объект Cmd, представляющий внешнюю программу и аргументы, из cmd, изменяя параметры необязательных ключевых аргументов:

• ignorestatus::Bool: Если true (по умолчанию false), то Cmd не будет генерировать ошибку, если возвращаемый код не равен нулю.

• detach::Bool: Если true (по умолчанию false), то Cmd будет выполняться в новой группе процессов, что позволит ему пережить процесс julia и не получать прерывания Ctrl-C.

• windows_verbatim::Bool: Если true (по умолчанию false), то в Windows Cmd будет отправлять строку командной строки в процесс без кавычек или экранирования аргументов, даже аргументов, содержащих пробелы. (В Windows аргументы передаются программе как одна строка "командной строки", и программы отвечают за ее разбор на аргументы. По умолчанию пустые аргументы и аргументы с пробелами или табуляциями заключаются в двойные кавычки " в командной строке, а \ или " предваряются обратными слешами. windows_verbatim=true полезно для запуска программ, которые анализируют свою командную строку нестандартными способами.) Не оказывает влияния на не-Windows системы.

• windows_hide::Bool: Если true (по умолчанию false), то в Windows при выполнении Cmd не отображается новое окно консоли. Это не оказывает влияния, если консоль уже открыта или на не-Windows системах.

• env: Установить переменные среды, которые будут использоваться при выполнении Cmd. env может быть словарем, сопоставляющим строки со строками, массивом строк вида "var=val", массивом или кортежем пар "var"=>val, или nothing. Чтобы изменить (а не заменить) существующую среду, создайте env с помощью copy(ENV) и затем установите env["var"]=val по мере необходимости.

• dir::AbstractString: Указать рабочую директорию для команды (вместо текущей директории).

Для любых ключевых слов, которые не указаны, используются текущие настройки из cmd. Обычно для создания объекта Cmd в первую очередь используются обратные кавычки, например:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

Base.setenvФункция

setenv(command::Cmd, env; dir="")

Установить переменные среды, которые будут использоваться при выполнении данной command. env может быть словарем, сопоставляющим строки со строками, массивом строк вида "var=val", или нулем или более пар "var"=>val. Чтобы изменить (а не заменить) существующую среду, создайте env с помощью copy(ENV) и затем установите env["var"]=val по мере необходимости, или используйте withenv.

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

Base.withenvФункция

withenv(f::Function, kv::Pair...)

Выполнить f() в среде, которая временно изменена (не заменена, как в setenv) нулем или более аргументами "var"=>val kv. withenv обычно используется через синтаксис withenv(kv...) do ... end. Значение nothing может использоваться для временного отключения переменной среды (если она установлена). При возврате из withenv, исходная среда восстанавливается.

Base.pipelineМетод

pipeline(from, to, ...)

Создать конвейер от источника данных до пункта назначения. Источник и пункт назначения могут быть командами, потоками ввода/вывода, строками или результатами других вызовов pipeline. По меньшей мере один аргумент должен быть командой. Строки относятся к именам файлов. При вызове более чем с двумя аргументами они цепляются друг за друга слева направо. Например, pipeline(a,b,c) эквивалентно pipeline(pipeline(a,b),c). Это обеспечивает более лаконичный способ задания многоступенчатых конвейеров.

Примеры:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

Base.pipelineМетод

pipeline(command; stdin, stdout, stderr, append=false)

Перенаправить ввод/вывод к или из указанного command. Ключевые аргументы указывают, какие потоки команды должны быть перенаправлены. append управляет тем, добавляет ли вывод файла к файлу. Это более общая версия функции pipeline с 2 аргументами. pipeline(from, to) эквивалентно pipeline(from, stdout=to), когда from является командой, и pipeline(to, stdin=from), когда from — другой тип источника данных.

Примеры:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

Base.Libc.gethostnameФункция

gethostname() -> AbstractString

Получить имя хоста локальной машины.

Base.getipaddrФункция

getipaddr() -> IPAddr

Получить IP-адрес локальной машины.

Base.Libc.getpidФункция

getpid() -> Int32

Получить идентификатор процесса Julia.

Base.Libc.timeМетод

time()

Получить системное время в секундах с момента эпохи с довольно высокой (обычно микросекундной) точностью.

Base.time_nsФункция

time_ns()

Получить время в наносекундах. Время, соответствующее 0, не определено и переполняется каждые 5,8 лет.

Base.ticФункция

tic()

Установить таймер, который будет считан при следующем вызове toc или toq. Макрос @time expr также может быть использован для измерения времени выполнения.

julia> tic()
0x0000c45bc7abac95

julia> sleep(0.3)

julia> toc()
elapsed time: 0.302745944 seconds
0.302745944

Base.tocФункция

toc()

Вывести и вернуть время, прошедшее с момента последнего вызова tic. Макрос @time expr также может быть использован для измерения времени выполнения.

julia> tic()
0x0000c45bc7abac95

julia> sleep(0.3)

julia> toc()
elapsed time: 0.302745944 seconds
0.302745944

Base.toqФункция

toq()

Возвращает, но не выводит, время, прошедшее с момента последнего вызова tic. Макрос @timed expr и @elapsed expr также возвращают время выполнения.

julia> tic()
0x0000c46477a9675d

julia> sleep(0.3)

julia> toq()
0.302251004

Base.@timeМакрос

@time

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

См. также @timev, @timed, @elapsed и @allocated.

julia> @time rand(10^6);
  0.001525 seconds (7 allocations: 7.630 MiB)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)

Base.@timevМакрос

@timev

Это подробная версия макроса @time. Сначала он выводит ту же информацию, что и @time, затем любые ненулевые счетчики выделения памяти и затем возвращает значение выражения.

См. также @time, @timed, @elapsed и @allocated.

julia> @timev rand(10^6);
  0.001006 seconds (7 allocations: 7.630 MiB)
elapsed time (ns): 1005567
bytes allocated:   8000256
pool allocs:       6
malloc() calls:    1

Base.@timedМакрос

@timed

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

См. также @time, @timev, @elapsed и @allocated.

julia> val, t, bytes, gctime, memallocs = @timed rand(10^6);

julia> t
0.006634834

julia> bytes
8000256

julia> gctime
0.0055765

julia> fieldnames(typeof(memallocs))
9-element Array{Symbol,1}:
 :allocd
 :malloc
 :realloc
 :poolalloc
 :bigalloc
 :freecall
 :total_time
 :pause
 :full_sweep

julia> memallocs.total_time
5576500

Base.@elapsedМакрос

@elapsed

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

См. также @time, @timev, @timed и @allocated.

julia> @elapsed sleep(0.3)
0.301391426

Base.@allocatedМакрос

@allocated

Макрос для оценки выражения, игнорируя результирующее значение, вместо этого возвращающее общее количество байтов, выделенных во время оценки выражения. Примечание: выражение оценивается внутри локальной функции, а не в текущем контексте, чтобы устранить влияние компиляции, однако, все ещё могут быть выделения из-за JIT-компиляции. Это также делает результаты несовместимыми с макросами @time, которые не пытаются скорректировать влияние компиляции.

См. также @time, @timev, @timed и @elapsed.

julia> @allocated rand(10^6)
8000080

Base.EnvHashТип

EnvHash() -> EnvHash

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

Base.ENVКонстанта

ENV

Ссылка на синглетон EnvHash, предоставляющий интерфейс словаря для системных переменных окружения.

Base.is_unixФункция

is_unix([os])

Предикат для проверки, предоставляет ли ОС интерфейс типа Unix. См. документацию в Обработка вариаций операционных систем.

Base.is_appleФункция

is_apple([os])

Предикат для проверки, является ли ОС производной от Apple Macintosh OS X или Darwin. См. документацию в Обработка вариаций операционных систем.

Base.is_linuxФункция

is_linux([os])

Предикат для проверки, является ли ОС производной от Linux. См. документацию в Обработка вариаций операционных систем.

Base.is_bsdФункция

is_bsd([os])

Предикат для проверки, является ли ОС производной от BSD. См. документацию в Обработка вариаций операционных систем.

Base.is_windowsФункция

is_windows([os])

Предикат для проверки, является ли ОС производной от Microsoft Windows NT. См. документацию в Обработка вариаций операционных систем.

Base.Sys.windows_versionФункция

Sys.windows_version()

Возвращает номер версии ядра Windows NT в виде пары (major, minor) или (0, 0), если это не Windows.

Base.@staticМакрос

@static

Частично оценивает выражение во время разбора.

Например, @static is_windows() ? foo : bar будет оценивать is_windows() и вставлять либо foo, либо bar в выражение. Это полезно в случаях, когда конструкция будет недействительна на других платформах, например, ccall для несуществующей функции. @static if is_apple() foo end и @static foo <&&,||> bar также являются допустимыми синтаксическими конструкциями.

Ошибки

Base.errorФункция

error(message::AbstractString)

Вызвать ErrorException с указанным сообщением.

Core.throwФункция

throw(e)

Выбросить объект в качестве исключения.

Base.rethrowФункция

rethrow([e])

Выбросить объект без изменения текущего стека вызовов исключения. По умолчанию аргумент — текущее исключение (если вызов находится в блоке catch).

Base.backtraceФункция

backtrace()

Получить объект стека вызовов для текущей точки программы.

Base.catch_backtraceФункция

catch_backtrace()

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

Base.assertФункция

assert(cond)

Выбросить AssertionError, если cond равно false . Также доступен в виде макроса @assert expr.

Base.@assertМакрос

@assert cond [text]

Выбросить AssertionError, если cond равно false . Предпочтительный синтаксис для записи утверждений. Сообщение text необязательно отображается при ошибке утверждения.

Base.ArgumentErrorТип

ArgumentError(msg)

Параметры вызова функции не соответствуют допустимой сигнатуре. Аргумент msg — строка описания ошибки.

Base.AssertionErrorТип

AssertionError([msg])

Утвержденное условие не вычислилось в true. Необязательный аргумент msg — это строка с описанием ошибки.

Core.BoundsErrorТип

BoundsError([a],[i])

Операция индексирования массива, a, попыталась получить доступ к элементу вне границ, i.

Base.DimensionMismatchТип

DimensionMismatch([msg])

Вызываемые объекты не имеют совпадающей размерности. Необязательный аргумент msg — это строка с описанием ошибки.

Core.DivideErrorТип

DivideError()

Была выполнена целочисленная операция деления на ноль.

Core.DomainErrorТип

DomainError()

Аргументы функции или конструктора выходят за допустимый диапазон.

Base.EOFErrorТип

EOFError()

Больше нет данных для чтения из файла или потока.

Core.ErrorExceptionТип

ErrorException(msg)

Общий тип ошибки. Сообщение об ошибке в поле .msg может содержать более подробные сведения.

Core.InexactErrorТип

InexactError()

Преобразование типа невозможно выполнить точно.

Core.InterruptExceptionТип

InterruptException()

Процесс был остановлен прерыванием терминала (CTRL+C).

Base.KeyErrorТип

KeyError(key)

Операция индексирования в объект Associative (Dict) или подобный Set попыталась получить доступ к или удалить несуществующий элемент.

Base.LoadErrorТип

LoadError(file::AbstractString, line::Int, error)

Возникла ошибка при includeнии, requireнии или using файла. Подробные сведения об ошибке должны быть доступны в поле .error.

Base.MethodErrorТип

MethodError(f, args)

Метод с требуемой сигнатурой типа отсутствует в данной обобщенной функции. Либо не существует уникального метода наибольшей специфичности.

Base.NullExceptionТип

NullException()

Попытка доступа к Nullable без определения значения.

Core.OutOfMemoryErrorТип

OutOfMemoryError()

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

Core.ReadOnlyMemoryErrorТип

ReadOnlyMemoryError()

Операция попыталась записать в область памяти только для чтения.

Core.OverflowErrorТип

OverflowError()

Результат выражения слишком велик для указанного типа и вызовет переполнение.

Base.ParseErrorТип

ParseError(msg)

Выражение, переданное функции parse, не может быть интерпретировано как допустимое выражение Julia.

Base.Distributed.ProcessExitedExceptionТип

ProcessExitedException()

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

Core.StackOverflowErrorТип

StackOverflowError()

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

Base.SystemErrorТип

SystemError(prefix::AbstractString, [errno::Int32])

Системный вызов завершился ошибкой с кодом ошибки (в глобальной переменной errno).

Core.TypeErrorТип

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Ошибка проверки типа или вызов внутренней функции с неправильным типом аргумента.

Core.UndefRefErrorТип

UndefRefError()

Элемент или поле не определены для данного объекта.

Core.UndefVarErrorТип

UndefVarError(var::Symbol)

Символ в текущем пространстве имен не определен.

Base.InitErrorТип

InitError(mod::Symbol, error)

Возникла ошибка при выполнении функции __init__ модуля. Фактическая ошибка доступна в поле .error.

Base.retryФункция

retry(f::Function;  delays=ExponentialBackOff(), check=nothing) -> Function

Возвращает анонимную функцию, которая вызывает функцию f. Если возникает исключение, f вызывается повторно, каждый раз check возвращает true, после ожидания количества секунд, указанного в delays. check должно принимать текущее состояние delays и Exception.

Примеры

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, UVError))(io, 128; all=false)

Base.ExponentialBackOffТип

ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

Итератор Float64 длиной n, элементы которого экспоненциально увеличиваются со скоростью в интервале factor * (1 ± jitter). Первый элемент — first_delay, а все элементы ограничены значением max_delay.

События

Base.TimerМетод

Timer(callback::Function, delay, repeat=0)

Создайте таймер для вызова заданной callback функции. Функция callback получает один аргумент — сам объект таймера. Обработчик будет вызван после указанного начального delay, а затем повторяться с заданным repeat интервалом. Если repeat равно 0, таймер срабатывает только один раз. Время задаётся в секундах. Таймер останавливается и освобождает ресурсы, вызывая close на нём.

Base.TimerТип

Timer(delay, repeat=0)

Создайте таймер, который будит задачи, ожидающие его (вызвав wait на объекте таймера) с заданным интервалом. Время задаётся в секундах. Ожидающие задачи будут пробуждены с ошибкой, когда таймер будет закрыт (методом close). Используйте isopen для проверки, активен ли таймер.

Base.AsyncConditionТип

AsyncCondition()

Создайте асинхронную условную переменную, которая будит задачи, ожидающие её (вызвав wait на объекте), при уведомлении из C вызовом uv_async_send. Ожидающие задачи будут пробуждены с ошибкой, когда объект будет закрыт (методом close). Используйте isopen для проверки, активна ли переменная.

Base.AsyncConditionМетод

AsyncCondition(callback::Function)

Создайте асинхронную условную переменную, которая вызывает заданную callback функцию. Функция callback получает один аргумент — сам объект асинхронной условной переменной.

Reflection

Base.module_nameФункция

module_name(m::Module) -> Symbol

Получить имя Module модуля в виде Symbol.

julia> module_name(Base.LinAlg)
:LinAlg

Base.module_parentФункция

module_parent(m::Module) -> Module

Получить модуль-окружение Module. Main является собственным родителем, как и LastMain после workspace().

julia> module_parent(Main)
Main

julia> module_parent(Base.LinAlg.BLAS)
Base.LinAlg

Base.current_moduleФункция

current_module() -> Module

Получить динамически текущий Module модуль, из которого в данный момент читается код. Как правило, это не то же самое, что модуль, содержащий вызов этой функции.

Base.fullnameФункция

fullname(m::Module)

Получить полное имя модуля как кортеж символов. Например,

julia> fullname(Base.Pkg)
(:Base, :Pkg)

julia> fullname(Main)
()

Base.namesФункция

names(x::Module, all::Bool=false, imported::Bool=false)

Получить массив имён, экспортируемых модулем Module, исключая устаревшие имена. Если all истинно, то список также включает не экспортируемые имена, определённые в модуле, устаревшие имена и имена, сгенерированные компилятором. Если imported истинно, то также включаются имена, явно импортированные из других модулей.

В качестве особого случая, все имена, определённые в Main, считаются "экспортированными", так как не является стандартной практикой явно экспортировать имена из Main.

Core.nfieldsФункция

nfields(x::DataType) -> Int

Получить количество полей DataType.

Base.fieldnamesФункция

fieldnames(x::DataType)

Получить массив имён полей DataType.

julia> fieldnames(Hermitian)
2-element Array{Symbol,1}:
 :data
 :uplo

Base.fieldnameФункция

fieldname(x::DataType, i::Integer)

Получить имя поля i DataType.

julia> fieldname(SparseMatrixCSC,1)
:m

julia> fieldname(SparseMatrixCSC,5)
:nzval

Base.datatype_moduleФункция

Base.datatype_module(t::DataType) -> Module

Определить модуль, содержащий определение DataType.

Base.datatype_nameФункция

Base.datatype_name(t) -> Symbol

Получить имя (возможно, обернутого UnionAll) DataType (без родительского модуля) в виде символа.

Base.isconstФункция

isconst([m::Module], s::Symbol) -> Bool

Определить, объявлен ли глобальный объект const в заданном Module. По умолчанию аргумент Module — current_module().

Base.function_nameФункция

Base.function_name(f::Function) -> Symbol

Получить имя обобщённой Function функции в виде символа или :anonymous.

Base.function_moduleМетод

Base.function_module(f::Function) -> Module

Определить модуль, содержащий (первое) определение обобщённой функции.

Base.function_moduleМетод

Base.function_module(f::Function, types) -> Module

Определить модуль, содержащий данное определение обобщённой функции.

Base.functionlocМетод

functionloc(f::Function, types)

Возвращает кортеж (filename,line), указывающий на расположение определения обобщённой Function функции.

Base.functionlocМетод

functionloc(m::Method)

Возвращает кортеж (filename,line), указывающий на расположение определения Method метода.

Base.@functionlocМакрос

@functionloc

Применяется к вызову функции или макроса. Он вычисляет аргументы указанного вызова и возвращает кортеж (filename,line), указывающий на расположение метода, который будет вызван для этих аргументов. Он обращается к функции functionloc.

Внутренние элементы

Base.gcФункция

gc()

Выполнить сборку мусора. Обычно это использовать не следует.

Base.gc_enableФункция

gc_enable(on::Bool)

Управлять включением сбора мусора с помощью булевого аргумента (true для включения, false для выключения). Возвращает предыдущее состояние GC. Отключение сбора мусора следует использовать только с большой осторожностью, так как это может привести к неограниченному росту использования памяти.

Base.macroexpandФункция

macroexpand(x)

Принимает выражение x и возвращает эквивалентное выражение со всеми макросами удалёнными (развёрнутое).

Base.@macroexpandМакрос

@macroexpand

Возвращает эквивалентное выражение со всеми макросами удалёнными (развёрнутое).

Существует тонкое различие между @macroexpand и macroexpand в том, что разворачивание происходит в различных контекстах. Это лучше всего видно на следующем примере:

julia> module M
           macro m()
               1
           end
           function f()
               (@macroexpand(@m), macroexpand(:(@m)))
           end
       end
M

julia> macro m()
           2
       end
@m (macro with 1 method)

julia> M.f()
(1, 2)

С помощью @macroexpand выражение разворачивается там, где @macroexpand появляется в коде (модуль M в примере). С помощью macroexpand выражение разворачивается в текущем модуле, где код был в конечном итоге вызван (REPL в примере). Обратите внимание, что при вызове macroexpand или @macroexpand непосредственно из REPL, оба этих контекста совпадают, поэтому различия нет.

Base.expandФункция

expand(x)

Принимает выражение x и возвращает эквивалентное выражение в пониженной форме. См. также code_lowered.

Base.code_loweredФункция

code_lowered(f, types)

Возвращает массив пониженных AST для методов, соответствующих заданной обобщённой функции и подписи типа.

Base.@code_loweredМакрос

@code_lowered

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает code_lowered для полученного выражения.

Base.code_typedФункция

code_typed(f, types; optimize=true)

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

Base.@code_typedМакрос

@code_typed

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает code_typed для полученного выражения.

Base.code_warntypeФункция

code_warntype([io::IO], f, types)

Выводит пониженные и с типом AST для методов, соответствующих заданной обобщённой функции и подписи типа в io, по умолчанию STDOUT. AST анотированы таким образом, что типы «не-листья» выделяются (если доступен цвет, отображаются красным). Это служит предупреждением о потенциальной нестабильности типов. Не все типы «не-листья» являются особенно проблематичными для производительности, поэтому результаты необходимо использовать с осторожностью. См. @code_warntype для получения дополнительной информации.

Base.@code_warntypeМакрос

@code_warntype

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает code_warntype для полученного выражения.

Base.code_llvmФункция

code_llvm([io], f, types)

Выводит сгенерированные LLVM биткоды для выполнения метода, соответствующего заданной обобщённой функции и подписи типа в io, по умолчанию STDOUT.

Вся метаданные и вызовы dbg.* удаляются из выводимого биткода. Используйте code_llvm_raw для полного IR.

Base.@code_llvmМакрос

@code_llvm

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает code_llvm для полученного выражения.

Base.code_nativeФункция

code_native([io], f, types, [syntax])

Выводит сгенерированные инструкции родного ассемблера для выполнения метода, соответствующего заданной обобщённой функции и подписи типа в io, по умолчанию STDOUT. Смена синтаксиса ассемблера с помощью символа параметра syntax устанавливается в :att для синтаксиса AT&T или :intel для синтаксиса Intel. По умолчанию вывод в формате AT&T.

Base.@code_nativeМакрос

@code_native

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает code_native для полученного выражения.

Base.precompileФункция

precompile(f,args::Tuple{Vararg{Any}})

Компилирует заданную функцию f для кортежа аргументов (типов) args, но не выполняет её.