Добро пожаловать на Летнюю школу Julia 0x7E9!

print("Всем привет!")

Всем привет!

Организационная информация

🖐️ Пять дней занятий

Лекции разной длительности: от 1 часа до 2.5 часов с перерывом

👉 Сопроводительные материалы в Сообществе engee.com/community

🤙 Тесты в конце каждой лекции: 2 попытки на каждый вопрос

🖖 Сертификат по окончанию, порог сдачи 70%

Если не добрали баллов, можно будет пересдать курс

✊ Давайте начнём!

Почему Engee

Не только командная строка и скрипты, но и…

Преднастроенное окружение

Инженерные приложения-калькуляторы с доступом к любому инструменту платформы

Окна с графиками, которые можно откреплять

Файловый браузер

Средства связи с внешними системами (API, Engee Device Manager и просто HTTPs)

и т.д.

Где находятся основные инструменты?

Файловый браузер

Редактор переменных

Редактор скриптов

Командная строка

Личный кабинет

Документация

Настройки внешнего вида интерфейса

Техподдержка

Зачем пользоваться Julia?

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

]add Quaternions

   Resolving package versions...
    Updating `~/.project/Project.toml`
  [94ee1d12] + Quaternions v0.7.6
    Updating `~/.project/Manifest.toml`
  [94ee1d12] + Quaternions v0.7.6
  [c1ae055f] + RealDot v0.1.0
  [56f22d72] + Artifacts v1.11.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v0.7.0
  [e66e0078] + CompilerSupportLibraries_jll v1.1.1+0
  [4536629a] + OpenBLAS_jll v0.3.27+1
  [8e850b90] + libblastrampoline_jll v5.11.0+0

using Quaternions
quat(0,1,0,0) * quat(0,0,1,0) * quat(0,0,0,1)

Quaternion{Int64}(-1, 0, 0, 0)

Чтобы создавать изящные программы

function alpha(x)
    return 1 + 2*x
end

alpha (generic function with 1 method)

α(x) = 1 + 2x

α (generic function with 1 method)

α(2) == alpha(2)

true

Чтобы пользоваться удобной математической нотацией

using PyCall
py"""
import numpy as np
V = np.random.rand(80,40)
D = np.random.rand(80,80)
print(V.T @ D**3 @ V)
"""

[[364.2768821  380.28913206 352.10624122 ... 391.29162775 378.0262535
  380.20409207]
 [370.75578449 383.57976558 357.36914943 ... 397.96291582 386.30895923
  384.43382294]
 [350.19373405 360.10380739 339.59020366 ... 372.43226919 361.47832098
  361.04303587]
 ...
 [385.53699729 399.73617673 375.9033329  ... 412.93291691 398.47806608
  403.51344108]
 [372.75598195 387.14379935 360.52727095 ... 396.88273206 387.44830767
  384.94432276]
 [377.23999844 391.69603632 368.8603892  ... 402.78686305 387.72359385
  394.53185025]]

V = rand(80,40)
D = rand(80,80)

V' * D.^3 * V

40×40 Matrix{Float64}:
 334.6    378.365  359.084  368.445  …  349.814  367.405  364.945  342.094
 367.809  419.177  396.002  405.704     383.951  403.306  403.256  377.386
 358.546  402.576  383.379  392.198     371.529  389.854  392.549  365.815
 365.975  416.191  392.655  403.274     379.97   400.26   400.607  375.942
 372.58   418.131  395.773  407.256     381.417  404.47   403.921  375.014
 342.101  391.855  370.337  379.383  …  353.379  374.064  374.793  352.108
 356.986  405.835  384.049  394.61      369.266  389.873  391.195  364.297
 382.587  431.884  408.466  417.651     397.726  417.334  418.764  389.296
 398.325  452.901  428.199  438.641     413.422  433.341  435.719  406.352
 353.836  399.864  378.167  388.526     363.248  384.434  385.864  360.223
 382.134  431.47   410.306  419.094  …  396.582  419.304  420.56   391.292
 384.718  435.904  413.736  420.811     398.087  419.346  419.656  392.607
 352.417  408.228  380.751  389.175     365.652  389.489  388.913  363.962
   ⋮                                 ⋱                             
 402.807  461.636  433.702  447.333     418.703  445.033  444.797  415.653
 346.785  393.823  369.899  378.192     354.797  379.217  377.516  353.656
 363.885  413.592  389.1    401.7    …  379.279  400.593  402.081  372.618
 359.931  407.68   383.46   396.205     372.705  393.809  393.058  365.642
 340.474  384.641  365.9    374.689     350.912  370.434  374.387  349.953
 366.562  415.887  395.07   403.495     379.537  399.844  403.81   376.299
 403.702  461.91   434.861  444.037     419.365  448.457  442.719  414.367
 359.387  403.196  384.284  396.685  …  372.094  392.649  397.284  365.823
 340.2    383.591  361.092  375.668     349.287  369.867  369.49   341.61
 360.968  405.414  383.737  393.653     367.597  390.884  390.184  366.708
 363.923  411.124  389.353  402.256     380.347  400.292  399.884  372.873
 337.75   382.169  359.92   373.44      349.702  371.57   371.089  347.1

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

include("compare_julia_python.jl")

Сравнение производительности Julia vs Python
==================================================

1. Рекурсивное вычисление Fib(35):
  0.063548 seconds (1.37 k allocations: 63.938 KiB, 8.56% compilation time)
Julia результат: 9227465
Python результат: 9227465
Время Julia: 0.058144516 секунд
Время Python: 2.5560309886932373 секунд

2. Итеративное вычисление Fib(1000000):
  7.928075 seconds (2.02 M allocations: 40.458 GiB, 29.82% gc time, 0.17% compilation time)
Julia результат: 546875 (последние 6 цифр)
Python результат: PyObject 546875
Время Julia: 7.233807459 секунд
Время Python: 2.5560309886932373 секунд

3. Сумма квадратов массива из 10000000 элементов:
  0.019883 seconds (4.08 k allocations: 207.016 KiB, 48.32% compilation time)
Julia результат: 3.333827783796399e6
Python результат: 3.333827783796399e6
Время Julia: 0.010473674 секунд
Время Python: 2.5560309886932373 секунд
NumPy результат: 3.333827783796384e6
Время NumPy: 0.018550872802734375 секунд

==================================================
ИТОГИ СРАВНЕНИЯ:
Рекурсивный Fib: Julia 25.8x быстрее
Итеративный Fib: Julia 1.8x быстрее
Сумма квадратов (цикл): Julia 188.0x быстрее
Сумма квадратов (NumPy): Julia 1.8x быстрее

include("compare_julia_matlab.jl")

Сравнение производительности Julia vs MATLAB
==================================================

1. Рекурсивное вычисление Fib(35):
  0.072074 seconds (75.35 k allocations: 11.726 MiB, 47.74% compilation time)

Julia результат: 9227465
MATLAB результат: 9227465
Время Julia: 0.059294685 секунд
Время MATLAB: 1.467095 секунд

2. Итеративное вычисление Fib(1000):
  0.038300 seconds (77.90 k allocations: 5.668 MiB, 99.55% compilation time)
Julia результат: 43466557686937456435...
MATLAB результат: 4.346655768693743e20...
Время Julia: 0.000139427 секунд
Время MATLAB: 0.004583 секунд

3. Сумма квадратов массива из 1000000 элементов:
  0.010562 seconds (9.68 k allocations: 2.151 MiB, 90.16% compilation time)
Julia результат: 333211.7153240353
MATLAB результат: 333211.7153240353
Время Julia: 0.001021368 секунд
Время MATLAB: 0.045406 секунд
MATLAB векторизованный результат: 333211.715324048
Время MATLAB векторизованный: 0.023309 секунд

4. Использование встроенных функций MATLAB:
Сумма квадратов через встроенные функции:
MATLAB встроенный результат: 333211.715324048
Время MATLAB встроенный: 0.001467 секунд

==================================================
ИТОГИ СРАВНЕНИЯ:
Рекурсивный Fib: Julia 25.2x быстрее
Итеративный Fib: Julia 31.9x быстрее
Сумма квадратов (цикл): Julia 45.4x быстрее

Сравнение завершено!

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

]status

Status `~/.project/Project.toml`
  [94ee1d12] Quaternions v0.7.6

EngeePkg.purge()

    Updating `~/.project/Project.toml`
  [94ee1d12] - Quaternions v0.7.6
    Updating `~/.project/Manifest.toml`
  [94ee1d12] - Quaternions v0.7.6
  [c1ae055f] - RealDot v0.1.0
  [56f22d72] - Artifacts v1.11.0
  [8f399da3] - Libdl v1.11.0
  [37e2e46d] - LinearAlgebra v1.11.0
  [9a3f8284] - Random v1.11.0
  [ea8e919c] - SHA v0.7.0
  [e66e0078] - CompilerSupportLibraries_jll v1.1.1+0
  [4536629a] - OpenBLAS_jll v0.3.27+1
  [8e850b90] - libblastrampoline_jll v5.11.0+0

Чтобы вы могли отладить программу вплоть до ассемблерного кода

1+2

3

@code_typed 1+2

CodeInfo(
1 ─ %1 = Base.add_int(x, y)::Int64
└──      return %1
) => Int64

@code_lowered 1+2

CodeInfo(
1 ─ %1 = Base.add_int
│   %2 = (%1)(x, y)
└──      return %2
)

@code_llvm 1+2

; Function Signature: +(Int64, Int64)
;  @ int.jl:87 within `+`
define i64 @"julia_+_101934"(i64 signext %"x::Int64", i64 signext %"y::Int64") #0 {
top:
  %0 = add i64 %"y::Int64", %"x::Int64"
  ret i64 %0
}

@code_native 1+2

	.text
	.file	"+"
	.globl	"julia_+_102279"                # -- Begin function julia_+_102279
	.p2align	4, 0x90
	.type	"julia_+_102279",@function
"julia_+_102279":                       # @"julia_+_102279"
; Function Signature: +(Int64, Int64)
; ┌ @ int.jl:87 within `+`
# %bb.0:                                # %top
; │ @ int.jl within `+`
	#DEBUG_VALUE: +:x <- $rdi
	#DEBUG_VALUE: +:y <- $rsi
	push	rbp
	mov	rbp, rsp
; │ @ int.jl:87 within `+`
	lea	rax, [rdi + rsi]
	pop	rbp
	ret
.Lfunc_end0:
	.size	"julia_+_102279", .Lfunc_end0-"julia_+_102279"
; └
                                        # -- End function
	.section	".note.GNU-stack","",@progbits

Чтобы программировать, сохраняя математический подход

using PyCall
py"print(list(range(1,20)))"

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

using MATLAB
mat"1:20"

1×20 Matrix{Float64}:
 1.0  2.0  3.0  4.0  5.0  6.0  7.0  …  15.0  16.0  17.0  18.0  19.0  20.0

print(collect(1:20))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Синтаксис MATLAB, Python и Julia

Operation	MATLAB	Python	Julia
Row vector: size (1, n)	A = [1 2 3]	A = np.array([1, 2, 3]).reshape(1, 3)	A = [1 2 3]
Column vector: size (n, 1)	A = [1; 2; 3]	A = np.array([1, 2, 3]).reshape(3, 1)	A = [1 2 3]'
1d array: size (n, )	Not possible	A = np.array([1, 2, 3])	A = [1; 2; 3] or A = [1, 2, 3]
Integers from j to n with step size k	A = j:k:n	A = np.arange(j, n+1, k)	A = j:k:n
Linearly spaced vector of k points	A = linspace(1, 5, k)	A = np.linspace(1, 5, k)	A = range(1, 5, length = k)