awesome mojo

很棒的魔力

Mojo — 一种适合所有开发人员、AI/ML 科学家和软件工程师的新编程语言。

精选的 Mojo 代码、问题解决、解决方案以及未来的库、框架、软件和资源的列表。

让我们在这里积累非常新的技术知识和最佳实践。

• 很棒的魔力
• Mojo 驱动的社区
• Mojo 官方文档

Mojo 是一种编程语言，它将 Python 的用户友好性与 C++ 和 Rust 的性能功能相结合。此外，Mojo 使用户能够利用庞大的 Python 库生态系统。

简而言之

• Mojo 允许您利用整个 Python 生态系统。
• Mojo 旨在成为 Python 的超集。
• 使 Mojo 与现有的 Python 程序兼容。
• Mojo 作为 Python 家族的一员。
• 应用于人工智能系统和人工智能领域。
• 异构系统的可扩展编程。
• 构建统一的全球 ML/AI 基础设施。
• 编译器内部的创新。
• 支持当前和新兴的硬件加速器。
• 系统编程功能。
• 利用现有的 MLIR 编译器生态系统。

你好魔力

Mojo 是一种新的编程语言，通过将最好的 Python 语法与系统编程和元编程相结合，弥合了研究和生产之间的差距。

hello.mojo或hello.文件扩展名可以是表情符号！

• 你好魔力

您可以阅读更多关于为什么 Modular 这样做为什么 Mojo

我们想要的是一种创新且可扩展的编程模型，可以针对人工智能领域普遍存在的加速器和其他异构系统。 ...应用人工智能系统需要解决所有这些问题，我们认为没有理由不能仅用一种语言来完成。于是，Mojo诞生了。

但 Python 已经很好地完成了它的工作 =)

我们认为没有必要在语言语法或社区方面进行创新。所以我们选择拥抱Python生态系统，因为它的使用如此广泛，它受到人工智能生态系统的喜爱，而且因为我们相信它是一门非常好的语言。

为什么叫莫乔？

Mojo 的意思是“神奇的魅力”或“神奇的力量”。我们认为这是一个为 Python 带来神奇力量的语言的合适名称：python：，包括为当今人工智能中普遍存在的加速器和其他异构系统解锁创新的编程模型。

Guido van Rossum仁慈的终身独裁者和Christopher Arthur Lattner杰出的发明家、创造者和 Mojo 的著名领袖 发音 =)

根据描述

• Mojo 词定义
• 魔力之声

背景及影响

谁知道这些编程语言会非常高兴，因为 Mojo 受益于从其他语言 Rust、Swift、Julia、Zig、Nim 等中学到的大量经验教训。

• Rust 引发了 C 革命，现在 Rust 进入了 Linux 内核。
• 从技术角度来看，Swift 让苹果变得美丽。
• 朱莉娅高性能。
• Nim 系统编程语言。
• Zig 通用编程语言。我们喜欢并关注它 =)

消息

[新的]

• Github 现在自动检测 Mojo 代码！

  

• Mojo 的简单快速 HTTP 框架！非常适合构建 Web 服务和简单​​的 API。对于莫吉西安人

• LLama 实施基准测试框架

• 自动 Python 到 Mojo 代码翻译

• 编程语言数据库研究

• 2023 年 10 月 19 日 Mojo 现已在 Mac 上推出！使用开发者控制台

• Chris Lattner：编程和人工智能的未来 |莱克斯·弗里德曼播客 #381

• Mojo 和 Python 类型系统解释 |克里斯·拉特纳和莱克斯·弗里德曼

• Mojo 可以运行 Python 代码吗？ |克里斯·拉特纳和莱克斯·弗里德曼

• 从 Python 切换到 Mojo 编程语言 |克里斯·拉特纳和莱克斯·弗里德曼

• 新的 GitHub 主题 mojo-lang。所以你可以遵循它。

  

• Guido van Rossum 关于 Mojo = Python 与 C++/GPU 性能？

• 具有一些基本操作的张量结构#251

• 矩阵 fn 与 numpy #267

• 关于 mojo 中的lambda和parameter闭包以及更高阶函数的更新 #244

• 2023 年 5 月 25 日，Python 的创建者和荣誉 BDFL 的 Guido van Rossum (gvanrossum#8415) 访问 Mojo 公共 Discord 聊天室

• 等待 GitHub 上的 Mojo 语法高亮显示

• 新版 Mojo 发布 2023-05-24

[老的]

莫乔

• 变更日志
• 讨论
• 问题

基准测试

工具

• hyperfine 命令行基准测试工具

brew install hyperfine

• macchina 一个注重性能的系统信息前端。

brew install macchina

• 用于绘图的 Python3 库

pip3 install numpy matplotlib scipy

• 代码转PNG图像

brew install silicon

基准测试环境

Python / Mojo / Codon / Rust 版本

 > python3 --version
Python 3.11.6

> mojo --version
mojo 0.4.0 (9e33b013)

> codon --version
0.16.3

> rustc --version
rustc 1.65.0-nightly (9243168fa 2022-08-31)

斐波那契数列

让我们找到斐波那契数列

N = 100

Python斐波那契数列递归

 def fibonacci_recursion ( n ):
    return n if n < 2 else fibonacci_recursion ( n - 1 ) + fibonacci_recursion ( n - 2 )
fibonacci_recursion ( 100 )

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json python_recursion.json ' python3 benchmarks/fibonacci_sequence/python_recursion.py '

结果：超时，1m 后我取消了计算

Python 斐波那契数列迭代

 def fibonacci_iteration ( n ):
    a , b = 0 , 1
    for _ in range ( n ):
        a , b = b , a + b
    return a
fibonacci_iteration ( 100 )

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/python_iteration.json ' python3 benchmarks/fibonacci_sequence/python_iteration.py '

结果：
基准1：python3 benchmarks/fibonacci_sequence/python_iteration.py
时间（平均值 ± σ）：16374.7 µs ± 904.0 µs [用户：11483.5 µs，系统：3680.0 µs]
范围（最小值 … 最大值）：15361.0 µs … 22863.3 µs 100 次运行

编译Python字节码

python3 -m compileall benchmarks/fibonacci_sequence/python_recursion.py
python3 -m compileall benchmarks/fibonacci_sequence/python_iteration.py

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/python_recursion.cpython-311.json ' python3 benchmarks/fibonacci_sequence/__pycache__/python_recursion.cpython-311.pyc '
# TIMEOUT!

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/python_iteration.cpython-311.json ' python3 benchmarks/fibonacci_sequence/__pycache__/python_iteration.cpython-311.pyc '

结果：
基准1：python3 benchmarks/fibonacci_sequence/ pycache /python_iteration.cpython-311.pyc
时间（平均值 ± σ）：16584.6 µs ± 761.5 µs [用户：11451.8 µs，系统：3813.3 µs]
范围（最小值 … 最大值）：15592.0 µs … 20953.2 µs 100 次运行

Mojo 斐波那契数列递归

 fn fibonacci_recursion ( n : Int) -> Int:
    return n if n < 2 else fibonacci_recursion(n - 1 ) + fibonacci_recursion(n - 2 )
fn main ():
    _ = fibonacci_recursion( 100 )

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/mojo_recursion.json ' mojo run benchmarks/fibonacci_sequence/mojo_recursion.mojo '

结果：超时，1m 后我取消了计算

Mojo 斐波那契数列迭代

 fn fibonacci_iteration ( n : Int) -> Int:
    var a : Int = 0
    var b : Int = 1
    for _ in range (n):
        a = b
        b = a + b
    return a
fn main ():
    _ = fibonacci_iteration( 100 )

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/mojo_iteration.json ' mojo run benchmarks/fibonacci_sequence/mojo_iteration.mojo '

结果：
基准1：mojo运行 benchmarks/fibonacci_sequence/mojo_iteration.mojo
时间（平均值 ± σ）：43852.7 µs ± 1353.5 µs [用户：38156.0 µs，系统：10407.3 µs]
范围（最小值 … 最大值）：42033.6 µs … 49357.3 µs 100 次运行

编译Mojo代码

mojo build benchmarks/fibonacci_sequence/mojo_recursion.mojo
mojo build benchmarks/fibonacci_sequence/mojo_iteration.mojo

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/mojo_recursion.exe.json ' ./benchmarks/fibonacci_sequence/mojo_recursion '
# TIMEOUT!

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/mojo_iteration.exe.json ' ./benchmarks/fibonacci_sequence/mojo_iteration '

结果：
基准1：./benchmarks/fibonacci_sequence/mojo_iteration
时间（平均值 ± σ）：934.6 µs ± 468.9 µs [用户：409.8 µs，系统：247.8 µs]
范围（最小值 … 最大值）：552.7 µs … 4522.9 µs 100 次运行

密码子斐波那契数列递归

 def fibonacci_recursion(n):
    return n if n < 2 else fibonacci_recursion(n - 1) + fibonacci_recursion(n - 2)
fibonacci_recursion(100)

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/codon_recursion.json ' codon run --release benchmarks/fibonacci_sequence/codon_recursion.codon '

结果：超时，1m 后我取消了计算

密码子斐波那契数列迭代

 def fibonacci_iteration(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a+b
    return a
fibonacci_iteration(100)

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/codon_iteration.json ' codon run --release benchmarks/fibonacci_sequence/codon_iteration.codon '

结果：
基准1：codon run --release benchmarks/fibonacci_sequence/codon_iteration.codon
时间（平均值 ± σ）：628060.1 µs ± 10430.5 µs [用户：584524.3 µs，系统：39358.5 µs]
范围（最小值 … 最大值）：612742.5 µs … 662716.9 µs 100 次运行

编译Codon代码

codon build --release -exe benchmarks/fibonacci_sequence/codon_recursion.codon
codon build --release -exe benchmarks/fibonacci_sequence/codon_iteration.codon

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json codon_recursion.exe.json ' ./benchmarks/fibonacci_sequence/codon_recursion '
# TIMEOUT!

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/codon_iteration.exe.json ' ./benchmarks/fibonacci_sequence/codon_iteration '

结果：
基准1：./benchmarks/fibonacci_sequence/codon_iteration
时间（平均值 ± σ）：2732.7 µs ± 1145.5 µs [用户：1466.0 µs，系统：1061.5 µs]
范围（最小值 … 最大值）：2036.6 µs … 13236.3 µs 100 次运行

Rust 斐波那契数列递归

 fn fibonacci_recursive ( n : i64 ) -> i64 {
    if n < 2 {
        return n ;
    }
    return fibonacci_recursive ( n - 1 ) + fibonacci_recursive ( n - 2 ) ;
}
fn main ( ) {
    let _ = fibonacci_recursive ( 100 ) ;
} 

rustc -C opt-level=3 benchmarks/fibonacci_sequence/rust_recursion.rs -o benchmarks/fibonacci_sequence/rust_recursion

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/rust_recursion.json ' ./benchmarks/fibonacci_sequence/rust_recursion '

结果：超时，1m 后我取消了计算

Rust 斐波那契数列迭代

 fn fibonacci_iteration ( n : usize ) -> usize {
    let mut a = 1 ;
    let mut b = 1 ;
    for _ in 1 ..n {
        let old = a ;
        a = b ;
        b += old ;
    }
    b
}
fn main ( ) {
    let _ = fibonacci_iteration ( 100 ) ;
} 

rustc -C opt-level=3 benchmarks/fibonacci_sequence/rust_iteration.rs -o benchmarks/fibonacci_sequence/rust_iteration

hyperfine --warmup 10 -r 100 --time-unit=microsecond --export-json benchmarks/fibonacci_sequence/rust_iteration.json ' ./benchmarks/fibonacci_sequence/rust_iteration '

结果：
基准1：./benchmarks/fibonacci_sequence/rust_iteration
时间（平均值 ± σ）：848.9 µs ± 283.2 µs [用户：371.8 µs，系统：261.4 µs]
范围（最小值 … 最大值）：525.9 µs … 2607.3 µs 100 次运行

斐波那契数列总结

 # Merge all JSON files into benchmarks.json
python3 benchmarks/hyperfine-scripts/merge_jsons.py benchmarks/fibonacci_sequence/ benchmarks/fibonacci_sequence/benchmarks.json

python3 benchmarks/hyperfine-scripts/plot2.py benchmarks/fibonacci_sequence/benchmarks.json

python3 benchmarks/hyperfine-scripts/plot3.py benchmarks/fibonacci_sequence/benchmarks.json

python3 benchmarks/hyperfine-scripts/advanced_statistics.py benchmarks/fibonacci_sequence/benchmarks.json > benchmarks/fibonacci_sequence/benchmarks.json.md

silicon benchmarks/fibonacci_sequence/benchmarks.json.md -l python -o benchmarks/fibonacci_sequence/benchmarks.json.md.png

高级统计

全部在一起

缩放

一一详述

地点

1. 锈
2. 莫乔
3. 密码子
4. Python

但这里有很多问题：

• 如何优化代码/构建/运行？
• 为什么mojo run这么慢？
• 为什么codon run --release这么慢？
• 为什么编译后的Python字节码+/-等于Python解释器？
• 为什么Python解释器比Mojo/Codon run得更快？

因此，我们可以说 Mojo 与 Mac 上的 Rust 一样快！

曼德尔布罗特集

让我们在哪里找到曼德尔布罗特集

宽度 = 960
高度 = 960
最大迭代数 = 200

MIN_X = -2.0
最大 X = 0.6
最小 Y = -1.5
最大Y = 1.5

Python 曼德尔布罗集

 def mandelbrot_kernel ( c ):
    z = c
    for i in range ( MAX_ITERS ):
        z = z * z + c  # Change this for different Multibrot sets (e.g., 2 for Mandelbrot)
        if z . real * z . real + z . imag * z . imag > 4 :
            return i
    return MAX_ITERS


def compute_mandelbrot ():
    t = [[ 0 for _ in range ( WIDTH )] for _ in range ( HEIGHT )] # Pixel matrix
    dx = ( MAX_X - MIN_X ) / WIDTH
    dy = ( MAX_Y - MIN_Y ) / HEIGHT
    for row in range ( HEIGHT ):
        for col in range ( WIDTH ):
            t [ row ][ col ] = mandelbrot_kernel ( complex ( MIN_X + col * dx , MIN_Y + row * dy ))
    return t


compute_mandelbrot ()

python3 -m compileall benchmarks/multibrot_set/multibrot.py

hyperfine --warmup 10 -r 10 --time-unit=microsecond --export-json benchmarks/multibrot_set/multibrot.cpython-311.json ' python3 benchmarks/multibrot_set/__pycache__/multibrot.cpython-311.pyc '

结果：
基准测试 1：python3 benchmarks/multibrot_set/ pycache /multibrot.cpython-311.pyc
时间（平均值 ± σ）：5444155.4 µs ± 23059.7 µs [用户：5419790.1 µs，系统：18131.3 µs]
范围（最小值 … 最大值）：5408155.3 µs … 5490548.4 µs 10 次运行

魔力曼德尔布罗集

Mojo 版本没有优化。

 # Compute the number of steps to escape.
def multibrot_kernel ( c : ComplexFloat64) -> Int:
    z = c
    for i in range ( MAX_ITERS ):
        z = z * z + c  # Change this for different Multibrot sets (e.g., 2 for Mandelbrot)
        if z.squared_norm() > 4 :
            return i
    return MAX_ITERS


def compute_multibrot () -> Tensor[FloatType]:
    # create a matrix. Each element of the matrix corresponds to a pixel
    t = Tensor[FloatType]( HEIGHT , WIDTH )

    dx = ( MAX_X - MIN_X ) / WIDTH
    dy = ( MAX_Y - MIN_Y ) / HEIGHT

    y = MIN_Y
    for row in range ( HEIGHT ):
        x = MIN_X
        for col in range ( WIDTH ):
            t[Index(row, col)] = multibrot_kernel(ComplexFloat64(x, y))
            x += dx
        y += dy
    return t


_ = compute_multibrot()

mojo build benchmarks/multibrot_set/multibrot.mojo

hyperfine --warmup 10 -r 10 --time-unit=microsecond --export-json benchmarks/multibrot_set/multibrot.exe.json ' ./benchmarks/multibrot_set/multibrot '

结果：
基准1：./benchmarks/multibrot_set/multibrot
时间（平均值 ± σ）：135880.5 µs ± 1175.4 µs [用户：133309.3 µs，系统：1700.1 µs]
范围（最小值 … 最大值）：134639.9 µs … 137621.4 µs 10 次运行

Mojo 并行曼德尔布罗集

 fn mandelbrot_kernel_SIMD [
    simd_width : Int
]( c : ComplexSIMD[float_type, simd_width]) -> SIMD [float_type, simd_width]:
    """ A vectorized implementation of the inner mandelbrot computation. """
    let cx = c.re
    let cy = c.im
    var x = SIMD [float_type, simd_width]( 0 )
    var y = SIMD [float_type, simd_width]( 0 )
    var y2 = SIMD [float_type, simd_width]( 0 )
    var iters = SIMD [float_type, simd_width]( 0 )

    var t : SIMD [DType.bool, simd_width] = True
    for i in range ( MAX_ITERS ):
        if not t.reduce_or():
            break
        y2 = y * y
        y = x.fma(y + y, cy)
        t = x.fma(x, y2) <= 4
        x = x.fma(x, cx - y2)
        iters = t.select(iters + 1 , iters)
    return iters


fn compute_multibrot_parallelized () -> Tensor[float_type]:
    let t = Tensor[float_type](height, width)

    @parameter
    fn worker ( row : Int):
        let scale_x = (max_x - min_x) / width
        let scale_y = (max_y - min_y) / height

        @parameter
        fn compute_vector [ simd_width : Int]( col : Int):
            """ Each time we operate on a `simd_width` vector of pixels. """
            let cx = min_x + (col + iota[float_type, simd_width]()) * scale_x
            let cy = min_y + row * scale_y
            let c = ComplexSIMD[float_type, simd_width](cx, cy)
            t.data().simd_store[simd_width](
                row * width + col, mandelbrot_kernel_SIMD[simd_width](c)
            )

        # Vectorize the call to compute_vector where call gets a chunk of pixels.
        vectorize[simd_width, compute_vector](width)

    # Parallelized
    parallelize[worker](height, height)
    return t


def main ():
    _ = compute_multibrot_parallelized()

mojo build benchmarks/multibrot_set/multibrot_mojo_parallelize.mojo

hyperfine --warmup 10 -r 10 --time-unit=microsecond --export-json benchmarks/multibrot_set/multibrot_mojo_parallelize.exe.json ' ./benchmarks/multibrot_set/multibrot_mojo_parallelize '

结果：
基准1：./benchmarks/multibrot_set/multibrot_mojo_parallelize
时间（平均值 ± σ）：7139.4 µs ± 596.4 µs [用户：36535.2 µs，系统：6670.1 µs]
范围（最小值 … 最大值）：6222.6 µs … 8269.7 µs 10 次运行

曼德尔布罗密码子集

 def mandelbrot_kernel(c):
    z = c
    for i in range(MAX_ITERS):
        z = z * z + c  # Change this for different Multibrot sets (e.g., 2 for Mandelbrot)
        if z.real * z.real + z.imag * z.imag > 4:
            return i
    return MAX_ITERS


def compute_mandelbrot():
    t = [[0 for _ in range(WIDTH)] for _ in range(HEIGHT)]  # Pixel matrix

    dx = (MAX_X - MIN_X) / WIDTH
    dy = (MAX_Y - MIN_Y) / HEIGHT

    @par(collapse=2)
    for row in range(HEIGHT):
        for col in range(WIDTH):
            t[row][col] = mandelbrot_kernel(complex(MIN_X + col * dx, MIN_Y + row * dy))
    return t


compute_mandelbrot()

用于测试运行或绘图（取消文件中代码的注释）

CODON_PYTHON=/opt/homebrew/opt/[email protected]/Frameworks/Python.framework/Versions/3.11/lib/libpython3.11.dylib codon run --release benchmarks/multibrot_set/multibrot.codon

构建并运行

codon build --release -exe benchmarks/multibrot_set/multibrot.codon -o benchmarks/multibrot_set/multibrot_codon

hyperfine --warmup 10 -r 10 --time-unit=microsecond --export-json benchmarks/multibrot_set/multibrot_codon.json ' ./benchmarks/multibrot_set/multibrot_codon '

结果：
基准1：./benchmarks/multibrot_set/multibrot_codon
时间（平均值 ± σ）：44184.7 µs ± 1142.0 µs [用户：248773.9 µs，系统：72935.3 µs]
范围（最小值 … 最大值）：42963.8 µs … 46456.2 µs 10 次运行

codon build --release -exe benchmarks/multibrot_set/multibrot_codon_par.codon -o benchmarks/multibrot_set/multibrot_codon_par

hyperfine --warmup 10 -r 10 --time-unit=microsecond --export-json benchmarks/multibrot_set/multibrot_codon_par.json ' ./benchmarks/multibrot_set/multibrot_codon_par ' 

摘要曼德尔布罗集

 # Merge all JSON files into benchmarks.json
python3 benchmarks/hyperfine-scripts/merge_jsons.py benchmarks/multibrot_set/ benchmarks/multibrot_set/benchmarks.json

python3 benchmarks/hyperfine-scripts/plot2.py benchmarks/multibrot_set/benchmarks.json

python3 benchmarks/hyperfine-scripts/plot3.py benchmarks/multibrot_set/benchmarks.json

python3 benchmarks/hyperfine-scripts/advanced_statistics.py benchmarks/multibrot_set/benchmarks.json > benchmarks/multibrot_set/benchmarks.json.md

silicon benchmarks/multibrot_set/benchmarks.json.md -l python -o benchmarks/multibrot_set/benchmarks.json.md.png

高级统计

全部在一起

缩放

一一详解

地点

1. Mojo（并行化）
2. 密码子
3. 莫乔
4. Python

链接：

• 多兄弟套装

Mandelbrot = Multibrot power = 2

 z = z ** power + c  # You can change this for different set

• 枕头内置 ImagingEffectMandelbrot

• Mandelbrot 的 Exaloop 密码子版本

• Mandelbrot 的模块化 Mojo 版本

• Mojo 复杂 squared_norm

• Matplotlib 曼德尔布罗特

很棒的 Mojo 代码

二分查找算法

在计算机科学中，二分搜索算法也称为半区间搜索、对数搜索或二分查找，是一种查找目标值在排序数组中的位置的搜索算法。

让我们使用 Python、Mojo、Swift、V、Julia、Nim、Zig 编写一些代码。

注意：对于Python和Mojo版本，我保留了一些优化并使代码相似以进行测量和比较。

Python 二分查找

 from typing import List
import timeit

SIZE = 1000000
MAX_ITERS = 100
COLLECTION = tuple ( i for i in range ( SIZE ))  # Make it aka at compile-time.


def python_binary_search ( element : int , array : List [ int ]) -> int :
    start = 0
    stop = len ( array ) - 1
    while start <= stop :
        index = ( start + stop ) // 2
        pivot = array [ index ]
        if pivot == element :
            return index
        elif pivot > element :
            stop = index - 1
        elif pivot < element :
            start = index + 1
    return - 1


def test_python_binary_search ():
    _ = python_binary_search ( SIZE - 1 , COLLECTION )


print (
    "Average execution time of func in sec" ,
    timeit . timeit ( lambda : test_python_binary_search (), number = MAX_ITERS ),
)

Mojo 二分搜索

 """Implements basic binary search."""

from Benchmark import Benchmark
from Vector import DynamicVector


alias SIZE = 1000000
alias NUM_WARMUP = 0
alias MAX_ITERS = 100


fn mojo_binary_search ( element : Int , array : DynamicVector [ Int ]) - > Int :
    var start = 0
    var stop = len ( array ) - 1
    while start <= stop :
        let index = ( start + stop ) // 2
        let pivot = array [ index ]
        if pivot == element :
            return index
        elif pivot > element :
            stop = index - 1
        elif pivot < element :
            start = index + 1
    return - 1


@ parameter  # statement runs at compile-time.
fn get_collection () - > DynamicVector [ Int ]:
    var v = DynamicVector [ Int ]( SIZE )
    for i in range ( SIZE ):
        v . push_back ( i )
    return v


fn test_mojo_binary_search () - > F64 :
    fn test_closure ():
        _ = mojo_binary_search ( SIZE - 1 , get_collection ())
    return F64 ( Benchmark ( NUM_WARMUP , MAX_ITERS ). run [ test_closure ]()) / 1e9


print (
    "Average execution time of func in sec " ,
    test_mojo_binary_search (),
)

这是第一个在 Mojoby 社区 (@ego) 中编写并发布在 mojo-chat 中的二分搜索。

Swift 二分查找

 func binarySearch ( items : [ Int ] , elem : Int ) -> Int {
    var low = 0
    var high = items . count - 1
    var mid = 0
    while low <= high {
        mid = Int ( ( high + low ) / 2 )
        if items [ mid ] < elem {
            low = mid + 1
        } else if items [ mid ] > elem {
            high = mid - 1
        } else {
            return mid
        }
    }
    return - 1
}

let items = [ 1 , 2 , 3 , 4 , 0 ] . sorted ( )
let res = binarySearch ( items : items , elem : 4 )
print ( res ) 

朱莉娅二分查找

 function binarysearch (lst :: Vector{T} , val :: T ) where T
    low = 1
    high = length (lst)
    while low ≤ high
        mid = (low + high) ÷ 2
        if lst[mid] > val
            high = mid - 1
        elseif lst[mid] < val
            low = mid + 1
        else
            return mid
        end
    end
    return 0
end 

Nim 二分查找

 proc binarySearch [T](a: openArray [T], key: T): int =
  var b = len (a)
  while result < b:
    var mid = ( result + b) div 2
    if a[mid] < key: result = mid + 1
    else : b = mid
  if result >= len (a) or a[ result ] != key: result = - 1


let res = @ [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 12 , 14 , 16 , 18 , 20 , 22 , 25 , 27 , 30 ]
echo binarySearch (res, 10 )

Zig 二分查找

 const std = @import ( "std" );

fn binarySearch ( comptime T : type , arr : [] const T , target : T ) ? usize {
    var lo : usize = 0 ;
    var hi : usize = arr . len - 1 ;

    while ( lo <= hi ) {
        var mid : usize = ( lo + hi ) / 2 ;

        if ( arr [ mid ] == target ) {
            return mid ;
        } else if ( arr [ mid ] < target ) {
            lo = mid + 1 ;
        } else {
            hi = mid - 1 ;
        }
    }

    return null ;
}

V 二分查找

 fn binary_search (a [] int , value int ) int {
    mut low := 0
    mut high := a.len - 1
    for low < = high {
        mid := (low + high) / 2
        if a[mid] > value {
            high = mid - 1
        } else if a[mid] < value {
            low = mid + 1
        } else {
            return mid
        }
    }
    return - 1
}

fn main () {
    search_list := [ 1 , 2 , 3 , 5 , 6 , 7 , 8 , 9 , 10 ]
    println ( binary_search (search_list, 9 ))
}

Bonus V 广度优先搜索路径

• vlang 的 BFS 示例
• BFS原创公关

 fn breadth_first_search_path (graph map [ string ][] string , vertex string , target string ) [] string {
    mut path := [] string {}
    mut visited := [] string {init: vertex}
    mut queue := [][][] string {}
    queue << [[vertex], path]
    for queue.len > 0 {
        mut idx := queue.len - 1
        node := queue[idx][ 0 ][ 0 ]
        path = queue[idx][ 1 ]
        queue. delete (idx)
        if node == target {
            path << node
            return path
        }
        for child in graph[node] {
            mut tmp := path. clone ()
            if child ! in visited {
                visited << child
                tmp << node
                queue << [[child], tmp]
            }
        }
    }
    return path
}

fn main () {
    graph := map {
        'A' : [ 'B' , 'C' ]
        'B' : [ 'A' , 'D' , 'E' ]
        'C' : [ 'A' , 'F' ]
        'D' : [ 'B' ]
        'E' : [ 'B' , 'F' ]
        'F' : [ 'C' , 'E' ]
    }
    println ( 'Graph: $graph ' )
    path := breadth_first_search_path (graph, 'A' , 'F' )
    println ( 'The shortest path from node A to node F is: $path ' )
    assert path == [ 'A' , 'C' , 'F' ]
}

嘶嘶声

• Leetcode Fizz 嗡嗡声问题
• 维基百科上的数据 菲兹嗡嗡声
• 根据维基百科的问题陈述，添加一些优化。

Python 嘶嘶声

 import timeit

SIZE = 100
MAX_ITERS = 100


def _fizz_buzz ():  # Make it aka at compile-time.
  res = []
  for n in range ( 1 , SIZE + 1 ):
    if ( n % 3 == 0 ) and ( n % 5 == 0 ):
      s = "FizzBuzz"
    elif n % 3 == 0 :
      s = "Fizz"
    elif n % 5 == 0 :
      s = "Buzz"
    else :
      s = str ( n )
    res . append ( s )
  return res


DATA = _fizz_buzz ()


def fizz_buzz ():
  print ( " n " . join ( DATA ))


print (
  "Average execution time of Python func in sec" ,
  timeit . timeit ( lambda : fizz_buzz (), number = MAX_ITERS ),
)

# Average execution time of Python func in sec 0.005334990004485007 

Clojure 菲兹嗡嗡声

( import '[java.io OutputStream])
( require '[clojure.java.io :as io])

( def devnull ( io/writer ( OutputStream/nullOutputStream )))

( defmacro timeit [n expr]
  `(with-out-str ( time
                   ( dotimes [_# ~( Math/pow 1 n)]
                     ( binding [*out* devnull]
                       ~expr)))))

( defmacro macro-fizz-buzz [n]
  `( fn []
    ( print
      ~( apply str
        ( for [i ( range 1 ( inc n))]
          ( cond
            ( zero? ( mod i 15 )) " FizzBuzz n "
            ( zero? ( mod i 5 ))  " Buzz n "
            ( zero? ( mod i 3 ))  " Fizz n "
            :else              ( str i " n " )))))))

( print ( timeit 100 ( macro-fizz-buzz 100 )))

; ; "Elapsed time: 0.175486 msecs"
; ; Average execution time of Clojure func in sec 0.000175486 seconds 

MojoFizz 嗡嗡声

 from String import String
from Benchmark import Benchmark

alias SIZE = 100
alias NUM_WARMUP = 0
alias MAX_ITERS = 100


@ parameter  # statement runs at compile-time.
fn _fizz_buzz () - > String :
    var res : String = ""
    for n in range ( 1 , SIZE + 1 ):
      if ( n % 3 == 0 ) and ( n % 5 == 0 ):
        res += "FizzBuzz"
      elif n % 3 == 0 :
        res += "Fizz"
      elif n % 5 == 0 :
        res += "Buzz"
      else :
        res += String ( n )
      res += " n "
    return res


fn fizz_buzz ():
    print ( _fizz_buzz ())

fn run_benchmark () - > F64 :
    fn _closure ():
        _ = fizz_buzz ()
    return F64 ( Benchmark ( NUM_WARMUP , MAX_ITERS ). run [ _closure ]()) / 1e9


print (
    "Average execution time of func in sec " ,
    run_benchmark (),
)

# Average execution time of func in sec  0.000104 

这是社区 (@Ego) 用 Mojo 编写的第一个 Fizz 嗡嗡声。

归并排序

我们将使用众所周知的算法参考书《算法简介 A3》中的算法

它的名气导致了缩写“ CLRS ”（Cormen、Leiserson、Rivest、Stein）的普遍使用，或者在第一版中为“ CLR ”（Cormen、Leiserson、Rivest）。

第 2 章“2.3.1 分治法”。

Python 归并排序

 % % python

import timeit

MAX_ITERS = 100


def merge ( A , p , q , r ):
    n1 = q - p + 1
    n2 = r - q
    L = [ None ] * n1
    R = [ None ] * n2
    for i in range ( n1 ):
        L [ i ] = A [ p + i ]
    for j in range ( n2 ):
        R [ j ] = A [ q + 1 + j ]
    i = 0
    j = 0
    k = p

    while i < n1 and j < n2 :
        if L [ i ] <= R [ j ]:
            A [ k ] = L [ i ]
            i += 1
        else :
            A [ k ] = R [ j ]
            j += 1
        k += 1

    while i < n1 :
        A [ k ] = L [ i ]
        i += 1
        k += 1

    while j < n2 :
        A [ k ] = R [ j ]
        j += 1
        k += 1


def merge_sort ( A , p , r ):
    if p < r :
        q = ( p + r ) // 2
        merge_sort ( A , p , q )
        merge_sort ( A , q + 1 , r )
        merge ( A , p , q , r )


def run_benchmark_merge_sort ():
    A = [ 14 , 72 , 50 , 83 , 18 , 20 , 13 , 30 , 17 , 87 , 94 , 65 , 24 , 99 , 70 , 44 , 5 , 12 , 74 , 6 , 32 , 63 , 91 , 88 , 43 , 54 , 27 , 39 , 64 , 78 , 29 , 62 , 58 , 59 , 61 , 89 , 2 , 15 , 41 , 9 , 93 , 90 , 23 , 96 , 73 , 14 , 8 , 28 , 11 , 42 , 77 , 34 , 52 , 80 , 57 , 84 , 21 , 60 , 66 , 40 , 7 , 85 , 47 , 98 , 97 , 35 , 82 , 36 , 49 , 3 , 68 , 22 , 67 , 81 , 56 , 71 , 4 , 38 , 69 , 95 , 16 , 48 , 1 , 31 , 75 , 19 , 10 , 25 , 79 , 45 , 76 , 33 , 53 , 55 , 46 , 37 , 26 , 51 , 92 , 86 ]
    merge_sort ( A , 0 , len ( A ) - 1 )

print (
  "Average execution time of Python `merge_sort` in sec" ,
  timeit . timeit ( lambda : run_benchmark_merge_sort (), number = MAX_ITERS ),
)
# Average execution time of Python `merge_sort` in sec 0.019136679999064654


def run_benchmark_sort ():
    A = [ 14 , 72 , 50 , 83 , 18 , 20 , 13 , 30 , 17 , 87 , 94 , 65 , 24 , 99 , 70 , 44 , 5 , 12 , 74 , 6 , 32 , 63 , 91 , 88 , 43 , 54 , 27 , 39 , 64 , 78 , 29 , 62 , 58 , 59 , 61 , 89 , 2 , 15 , 41 , 9 , 93 , 90 , 23 , 96 , 73 , 14 , 8 , 28 , 11 , 42 , 77 , 34 , 52 , 80 , 57 , 84 , 21 , 60 , 66 , 40 , 7 , 85 , 47 , 98 , 97 , 35 , 82 , 36 , 49 , 3 , 68 , 22 , 67 , 81 , 56 , 71 , 4 , 38 , 69 , 95 , 16 , 48 , 1 , 31 , 75 , 19 , 10 , 25 , 79 , 45 , 76 , 33 , 53 , 55 , 46 , 37 , 26 , 51 , 92 , 86 ]
    A . sort ()

print (
    "Average execution time of Python builtin `sort` in sec" ,
    timeit . timeit ( lambda : run_benchmark_sort (), number = MAX_ITERS ),
)
# Average execution time of Python builtin `sort` in sec 0.00019922800129279494 

Mojo 合并排序

 from Benchmark import Benchmark
from Vector import DynamicVector
from StaticTuple import StaticTuple
from Sort import sort

alias NUM_WARMUP = 0
alias MAX_ITERS = 100


fn merge ( inout A : DynamicVector [ Int ], p : Int , q : Int , r : Int ):
    let n1 = q - p + 1
    let n2 = r - q

    var L = DynamicVector [ Int ]( n1 )
    var R = DynamicVector [ Int ]( n2 )

    for i in range ( n1 ):
        L [ i ] = A [ p + i ]
    for j in range ( n2 ):
        R [ j ] = A [ q + 1 + j ]

    var i = 0
    var j = 0
    var k = p

    while i < n1 and j < n2 :
        if L [ i ] <= R [ j ]:
            A [ k ] = L [ i ]
            i += 1
        else :
            A [ k ] = R [ j ]
            j += 1
        k += 1

    while i < n1 :
        A [ k ] = L [ i ]
        i += 1
        k += 1

    while j < n2 :
        A [ k ] = R [ j ]
        j += 1
        k += 1


fn merge_sort ( inout A : DynamicVector [ Int ], p : Int , r : Int ):
    if p < r :
        let q = ( p + r ) // 2
        merge_sort ( A , p , q )
        merge_sort ( A , q + 1 , r )
        merge ( A , p , q , r )


@ parameter
fn create_vertor () - > DynamicVector [ Int ]:
    let st = StaticTuple [ MAX_ITERS , Int ]( 14 , 72 , 50 , 83 , 18 , 20 , 13 , 30 , 17 , 87 , 94 , 65 , 24 , 99 , 70 , 44 , 5 , 12 , 74 , 6 , 32 , 63 , 91 , 88 , 43 , 54 , 27 , 39 , 64 , 78 , 29 , 62 , 58 , 59 , 61 , 89 , 2 , 15 , 41 , 9 , 93 , 90 , 23 , 96 , 73 , 14 , 8 , 28 , 11 , 42 , 77 , 34 , 52 , 80 , 57 , 84 , 21 , 60 , 66 , 40 , 7 , 85 , 47 , 98 , 97 , 35 , 82 , 36 , 49 , 3 , 68 , 22 , 67 , 81 , 56 , 71 , 4 , 38 , 69 , 95 , 16 , 48 , 1 , 31 , 75 , 19 , 10 , 25 , 79 , 45 , 76 , 33 , 53 , 55 , 46 , 37 , 26 , 51 , 92 , 86 )
    var v = DynamicVector [ Int ]( st . __len__ ())
    for i in range ( st . __len__ ()):
        v . push_back ( st [ i ])
    return v


fn run_benchmark_merge_sort () - > F64 :
    fn _closure ():
        var A = create_vertor ()
        merge_sort ( A , 0 , len ( A ) - 1 )
    return F64 ( Benchmark ( NUM_WARMUP , MAX_ITERS ). run [ _closure ]()) / 1e9

print (
    "Average execution time of Mojo `merge_sort` in sec " ,
    run_benchmark_merge_sort (),
)
# Average execution time of Mojo `merge_sort` in sec 1.1345999999999999e-05


fn run_benchmark_sort () - > F64 :
    fn _closure ():
        var A = create_vertor ()
        sort ( A )
    return F64 ( Benchmark ( NUM_WARMUP , MAX_ITERS ). run [ _closure ]()) / 1e9

print (
    "Average execution time of Mojo builtin `sort` in sec " ,
    run_benchmark_sort (),
)
# Average execution time of Mojo builtin `sort` in sec 2.988e-06

您可以像这样使用它：

 # Usage: merge_sort

var A = create_vertor ()
merge_sort ( A , 0 , len ( A ) - 1 )

print ( len ( A ))
print ( A [ 0 ], A [ 99 ])

内置的from Sort import sort快速排序比我们的实现要快一点，但是我们可以在深入的语言中优化它，并像往常一样使用算法 =) 和编程范例。

• 多线程算法、多线程合并排序位于上述CLRS书的第 797、803 页
• 三个匈牙利人的算法
• 对于小子数组使用插入排序，混合归并排序
• 向不同方向合并
• 使用自适应方法
• 实施就地合并
• 优化内存访问
• Mojo 标准库功能
• 平铺合并排序就像平铺 Matmul 中的那样
• 并行多路归并排序

排序算法总结：归并排序和快速排序

郎	秒
Python 合并排序	0.019136679
Python 内置排序	0.000199228
Mojo合并排序	0.000011346
Mojo 内置排序	0.000002988

让我们为该表绘制一个图。

 #%%python

import matplotlib . pyplot as plt
import numpy as np

languages = [ 'Python merge_sort' , 'Python builtin sort' , 'Mojo merge_sort' , 'Mojo builtin sort' ]
seconds = [ 0.019136679 , 0.000199228 , 0.000011346 , 0.000002988 ]

# Apply a custom transformation to the values
transformed_seconds = [ np . sqrt ( 1 / x ) for x in seconds ]

plt . barh ( languages , transformed_seconds )
plt . xlabel ( 'Custom Transformation' )
plt . ylabel ( 'Language and Sort Type' )
plt . title ( 'Comparison of Sorting Algorithms (Custom Transformation)' )

plt . show ()

情节笔记，越多越好、越快。

编程手册

参数化[]：编译时元编程

我强烈建议从这里 HelloMojo 开始，并在这里了解[参数]和[参数表达式]参数化。就像这个例子一样：

 fn concat [ len1 : Int , len2 : Int ]( lhs : MySIMD [ len1 ], rhs : MySIMD [ len2 ]) - > MySIMD [ len1 + len2 ]:
    let result = MySIMD [ len1 + len2 ]()
    for i in range ( len1 ):
        result [ i ] = lhs [ i ]
    for j in range ( len2 ):
        result [ len1 + j ] = rhs [ j ]
    return result


let a = MySIMD [ 2 ]( 1 , 2 )
let x = concat [ 2 , 2 ]( a , a )
x . dump ()

编译时【参数】： fn concat[len1: Int, len2: Int] 。

运行时（参数） ： fn concat(lhs: MySIMD, rhs: MySIMD) 。

参数 PEP695 语法位于方[]括号中。

现在在Python中：

 def func ( a : _T , b : _T ) -> _T :
    ...

现在在Mojo：

 def func [ T ]( a : T , b : T ) -> T :
    ...

[参数]的命名和类型与 Mojo 程序中的普通值类似，但parameters[]是在编译时评估的。

运行时程序可以使用[参数]的值 - 因为参数在运行时程序需要它们之前在编译时解析 - 但编译时参数表达式可能不使用运行时值。

PEP673 中的Self键入

 fn __sub__ ( self , rhs : Self ) - > Self :
    let result = MySIMD [ size ]()
    for i in range ( size ):
        result [ i ] = self [ i ] - rhs [ i ]
    return result

在文档中，您可以找到“字段”一词，它在 Python 中又称为“类属性” 。

所以，你用dot来称呼它们。

 from DType import DType
let bool_type = DType . bool 

数据类型模型和别名

• 基本构造块是 DType。一些类比：
  • NumPy 数据类型
  • Jax 数据类型
  • TensorFlow DType

 from DType import DType
DType . si8

• 然后你可以用SIMD 结构（又名容器）包装它。
• SIMD 单指令、多数据和 SIMD（维基百科）

 from DType import DType
from SIMD import SIMD , SI8

alias MY_SIMD_DType_si8 = SIMD [ DType . si8 , 1 ]
alias MY_SI8 = SI8
print ( MY_SIMD_DType_si8 == MY_SI8 )
# true

• 然后，您可以使用 DynamicVector 或类似容器包装这些类型的序列。

 from DType import DType
from SIMD import SIMD , SI8
from Vector import DynamicVector
from String import String

alias a = DynamicVector [ SIMD [ DType . si8 , 1 ]]
alias b = DynamicVector [ SI8 ]
print ( a == b )
print ( a == String )
print ( b == String )
# all true

所以String只是DynamicVector[SIMD[DType.si8, 1]]之类的别名。

用于解构/解包/访问参数VariadicList

 from List import VariadicList

fn destructuring_arguments ( * args : Int ):
    let my_var_list = VariadicList ( args )
    for i in range ( len ( my_var_list )):
        print ( "argument" , i , ":" , my_var_list [ i ])

destructuring_arguments ( 1 , 2 , 3 , 4 )

它对于创建初始集合非常有用。我们可以这样写：

 from Vector import DynamicVector
from StaticTuple import StaticTuple

fn create_vertor () - > DynamicVector [ Int ]:
    let st = StaticTuple [ 4 , Int ]( 1 , 2 , 3 , 4 )
    var v = DynamicVector [ Int ]( st . __len__ ())
    for i in range ( st . __len__ ()):
    v . push_back ( st [ i ])
    return v

v = create_vertor ()
print ( v [ 0 ], v [ 3 ])

# or
from List import VariadicList

fn create_vertor () - > DynamicVector [ Int ]:
  let var_list = VariadicList ( 1 , 2 , 3 , 4 )
  var v = DynamicVector [ Int ]( len ( var_list ))
  for i in range ( len ( var_list )):
    v . push_back ( var_list [ i ])
  return v

v = create_vertor ()
print ( v [ 0 ], v [ 3 ])

阅读有关函数 def 和 fn 的更多信息

细绳

 from String import String
# String concatenation
print ( String ( "'" ) + String ( 1 ) + "' n " )

# Python's join
print ( String ( "|" ). join ( "a" , "b" , "c" ))

# String format
from IO import _printf as print
let x : Int = 1
print ( "'%i' n " , x . value )

字符串和内置切片

对于字符串，您可以使用内置切片，格式为字符串 slice[start:end:step]。

 from String import String

let hello_mojo = String ( "Hello Mojo!" )
print ( "Till the end:" , hello_mojo [ 0 ::])
print ( "Before last 2 chars:" , hello_mojo [ 0 : - 2 ])
print ( "From start to the end with step 2:" , hello_mojo [ 0 :: 2 ])
print ( "From start to the before last with step 3:" , hello_mojo [ 0 : - 1 : 3 ])

切片时 unicode 存在一些问题：

 let hello_mojo_unicode = String ( "Hello Mojo!" )
print ( "Unicode efore last 2 chars:" , hello_mojo_unicode [ 0 : - 2 ])
# no result, silents

这是一个解释和一些讨论。

mbstowcs - 将多字节字符串转换为宽字符字符串

Mojo装饰者

@价值

struct装饰器又名 Python @dataclass 。它会自动为您生成方法__init__ 、 __copyinit__ 、 __moveinit__ 。

 @ value
struct dataclass :
    var name : String
    var age : Int

请注意， @value装饰器仅适用于成员copyable和/或movable类型。

@值（“微不足道”）

@register_passable(“微不足道”)

琐碎的类型。这个装饰器告诉 Mojo 该类型应该是可复制的__copyinit__和可移动的__moveinit__ 。它还告诉 Mojo 更喜欢传递 CPU 寄存器中的值。允许structs选择在register中传递而不是通过memory传递。

 @ register_passable ( "trivial" )
struct Int :
    var value : __mlir_type . `!pop.scalar<index>`

@always_inline

提供对编译器优化的完全控制的装饰器。指示编译器在调用该函数时始终内联该函数。

 @ always_inline
fn foo ( x : Int , y : Int ) - > Int :
    return x + y

fn bar ( z : Int ):
    let r = foo ( z , z ) # This call will be inlined

@范围

它可以放置在捕获运行时值的嵌套函数上，以创建“参数”捕获闭包。它允许捕获运行时值的闭包作为参数值传递。

装饰组合

 @ always_inline
@ parameter
fn test (): return 

铸件

一些铸造示例

 s : StringLiteral
let p = DTypePointer [ DType . si8 ]( s . data ()). bitcast [ DType . ui8 ]()
var result = 0
result += (( p . simd_load [ 64 ]( offset ) >> 6 ) != 0b10 ). cast [ DType . ui8 ](). reduce_add (). to_int ()
let rest_p : DTypePointer [ DType . ui8 ] = stack_allocation [ simd_width , UI8 , 1 ]()

from Bit import ctlz
s : String
i : Int
let code = s . buffer . data . load ( i )
let byte_length_code = ctlz ( ~ code ). to_int ()

堆栈、内存、指针、分配、自由

DTypePointer、堆和堆栈

DTypePointer - 存储具有给定 DType 的地址，允许您通过方便地访问 SIMD 操作来分配、加载和修改数据。

 from Pointer import DTypePointer
from DType import DType
from Random import rand
from Memory import memset_zero

# `heap`
var my_pointer_on_heap = DTypePointer [ DType . ui8 ]. alloc ( 8 )
memset_zero ( my_pointer_on_heap , 8 )

# `stack or register`
var data = my_pointer_on_heap . simd_load [ 8 ]( 0 )
print ( data )

rand ( my_pointer_on_heap , 4 )

# `data` does not contain a reference to the `heap`, so load the data again
data = my_pointer_on_heap . simd_load [ 8 ]( 0 )
print ( data )

# simd_load and simd_store
var half = my_pointer_on_heap . simd_load [ 4 ]( 0 )
half = half + 1
my_pointer_on_heap . simd_store [ 4 ]( 4 , half )
print ( my_pointer_on_heap . simd_load [ 8 ]( 0 ))

# Pointer move back
my_pointer_on_heap -= 1
print ( my_pointer_on_heap . simd_load [ 8 ]( 0 ))

# Mast free memory
my_pointer_on_heap . free ()

struct可以通过限制scoup来最小化指针的潜在危险。

Mojo Dojo 博客上关于 DTypePointer 的优秀文章在这里

加上他的示例 Matrix Struct 和 DTypePointer

指针

指针将地址存储到任何register_passable type ，并将其中n地址分配给heap 。

 from Pointer import Pointer
from Memory import memset_zero
from String import String

@ register_passable  # for syntaxt like `let coord = p1[0]` and let it be passed through registers.
struct Coord :  # memory-only type
    var x : UI8
    var y : UI8

var p1 = Pointer [ Coord ]. alloc ( 2 )

memset_zero ( p1 , 2 )
var coord = p1 [ 0 ]  # is an identifier to memory on the stack or in a register
print ( coord . x )

# Store the value

coord . x = 5
coord . y = 5
print ( coord . x )

# We need to store the data.
p1 . store ( 0 , coord )
print ( p1 [ 0 ]. x )

# Mast free memory
p1 . free ()

关于指针的完整文章

再加上指针和结构体的例子

高级 Mojofeatures 和 Intrinsics 模块

模块化内在，它是某种执行后端：

• Mojo编译器功能
• LLVM 内在可能是这个
• 外部调用如libc
• MLIR 多级中间表示

Mojo-> MLIR 方言 -> 具有优化代码和架构的执行后端。

MLIR 是一个编译器基础设施，可为不同的编程语言和体系结构实现各种转换和优化过程。

系统调用

MLIR 本身并不直接提供与操作系统系统调用交互的功能。

它们是操作系统服务的低级接口，通常在目标编程语言或操作系统本身的级别进行处理。 MLIR 被设计为与语言和目标无关，其主要重点是提供用于执行优化的中间表示。要在 MLIR 中执行操作系统系统调用，我们需要使用特定于目标的后端。

但有了这些execution backends ，基本上，我们就可以访问操作系统系统调用。我们拥有 C/LLVM/Python 的整个世界。

让我们在实践中快速了解一下：

 from OS import getenv

print ( getenv ( "PATH" ))
print ( getenv ( StringRef ( "PATH" )))

# or like this
from SIMD import SI8
from Intrinsics import external_call

var path1 = external_call [ "getenv" , StringRef ]( StringRef ( "PATH" ))
print ( path1 . data )

var path2 = external_call [ "getenv" , StringRef ]( "PATH" )
print ( path2 . data )

let abs_10 = external_call [ "abs" , SI8 , Int ]( - 10 )
print ( abs_10 )

在这个简单的示例中，我们使用external_call来获取具有 Mojo 和 libc 函数之间的转换类型的操作系统环境变量。很酷，是啊！

我对这个主题有很多想法，我热切地等待着尽快实现它们的机会。采取行动可以带来惊人的结果 =)

MLIR libc gethostname

让我们做一些有趣的事情 - 调用libc function gethostname。

函数具有此接口int gethostname (char *name, size_t size) 。

为此，我们可以使用Intrinsics模块中的辅助函数 external_call 或编写自己的 MLIR。

我们来写代码吧：

 from Intrinsics import external_call
from SIMD import SIMD , SI8
from DType import DType
from Vector import DynamicVector
from DType import DType
from Pointer import DTypePointer , Pointer

# We can use `from String import String` but for clarification we will use a full form.
# DynamicVector[SIMD[DType.si8, 1]] == DynamicVector[SI8] == String

# Compile time stuff.
alias cArrayOfStrings = DynamicVector [ SIMD [ DType . si8 , 1 ]]
alias capacity = 1024

var c_pointer_to_array_of_strings = DTypePointer [ DType . si8 ]( cArrayOfStrings ( capacity ). data )
var c_int_result = external_call [ "gethostname" , Int , DTypePointer [ DType . si8 ], Int ]( c_pointer_to_array_of_strings , capacity )
let mojo_string_result = String ( c_pointer_to_array_of_strings . address )

print ( "C function gethostname result code:" , c_int_result )
print ( "C function gethostname result value:" , star_hostname ( mojo_string_result ))


@ always_inline
fn star_hostname ( hostname : String ) - > String :
    # [Builtin Slice](https://docs.modular.com/mojo/MojoBuiltin/BuiltinSlice.html)
    # string slice[start:end:step]
    return hostname [ 0 : - 1 : 2 ]

带有 Python 接口的 MojoTCP 套接字服务器

让我们用 Mojo 为 WEB 做一些事情。我们无法访问 Playground.modular.com，但我们可以在一台机器上做一些有趣的事情，比如 TCP。

让我们使用 PythonInterface 在 Mojo 中编写第一个 TCP 客户端-服务器代码

• Mojo TCP 套接字服务器
• Mojo TCP 客户端服务器

您应该创建两个单独的笔记本，并首先运行TCPSocketServer然后运行​​TCPSocketClient 。

此代码的Python 版本几乎相同，除了：

• with语法
• let分配
• 以及像a, b = (1, 2)这样的解构

• Pytohn 套接字低级网络接口
• 用于网络服务器的 Pytohn socketserver 框架

MojoFastAPI 与 Python 接口

在 Mojo 中的 TCP 服务器之后我们将继续前进 =)

这很疯狂，但让我们尝试使用 Mojo 运行现代 Python Web 服务器 FastAPI！

准备

我们需要将 FastAPI 代码上传到 Playground。所以，在你的本地机器上做

pip install --target=web fastapi uvicorn
tar -czPf web.tar.gz web

并通过Web界面将web.tar.gz上传到playground。

然后我们需要install它，只需放入适当的文件夹即可：

 % % python
import os
import site

site_packages_path = site . getsitepackages ()[ 0 ]
# install fastapi
os . system ( f"tar xzf web.tar.gz -C { site_packages_path } " )
os . system ( f"cp -r { site_packages_path } /web/* { site_packages_path } /" )
os . system ( f"ls { site_packages_path } | grep fastapi" )
# clean packages
os . system ( f"rm -rf { site_packages_path } /web" )
os . system ( f"rm web.tar.gz" )

MojoFastAPI服务器

 from PythonInterface import Python

# Python fastapi
let fastapi = Python . import_module ( "fastapi" )
let uvicorn = Python . import_module ( "uvicorn" )

var app = fastapi . FastAPI ()
var router = fastapi . APIRouter ()

# tricky part
let py = Python ()
let py_code = """lambda: 'Hello Mojo!'"""
let py_obj = py . evaluate ( py_code )
print ( py_obj )

router . add_api_route ( "/mojo" , py_obj )
app . include_router ( router )

print ( "Start FastAPI WEB Server" )
uvicorn . run ( app )
print ( "Done" )

MojoFastAPI 客户端

 from PythonInterface import Python
let http_client = Python . import_module ( "http.client" )

let conn = http_client . HTTPConnection ( "localhost" , 8000 )
conn . request ( "GET" , "/mojo" )
let response = conn . getresponse ()
print ( response . status , response . reason , response . read ())

像往常一样，您应该创建两个单独的笔记本，并首先运行FastAPI ，然后运行​​FastAPIClient 。

• MojoFastAPI服务器
• MojoFastAPI 服务器 Jupyter Notebook
• MojoFastAPI 客户端
• MojoFastAPI 客户端 Jupyter Notebook

有很多悬而未决的问题，但基本上我们实现了目标。

莫乔干得好！

一些开放性问题：

• 缺乏Python语法糖
• 缺乏隐式转换为 Python 对象的 Mojo 类型
• 如何将 Mojo 函数传递到 Python 空间/函数中

 from PythonInterface import Python

let pyfn = Python . evaluate ( "lambda x, y: x+y" )
let functools = Python . import_module ( "functools" )
print ( functools . reduce ( pyfn , [ 1 , 2 , 3 , 4 ]))

# How to, without Mojo pyfn.so?
def pyfn ( x , y ):
    retyrn x + y

未来看起来非常乐观！

链接：

• Python 中的 Mojo 类型
• Mojo 中的 Mandelbrot 与 Python 绘图

代码实现

辐射传输

Nick Wogan 的基准 Mojo 与 Numba

即时和日期时间本地

时间实用程序 Samay Kapadia @Zalando

主意

从 VSCode 或 DataSpell 连接到您的 mojo Playground

Python接口和读取文件

通过马克西姆·扎克斯

 from String import String
from PythonInterface import Python

let pathlib = Python . import_module ( 'pathlib' )
let txt = pathlib . Path ( 'nfl.csv' ). read_text ()
let s : String = txt . to_string ()

libc 实现

指针数据

 from DType import DType
from Buffer import Buffer
from Pointer import Pointer
from String import String , chr

let hello = "hello"
let pointer = Pointer ( hello . data ())

print ( "variant 1" )
var result = String ()
for i in range ( len ( hello )):
    result += chr ( pointer . bitcast [ Int8 ](). offset ( i ). load (). to_int ())
print ( result )

print ( "variant 2" )
print ( StringRef ( hello . data ()))

print ( "variant 3" )
print ( StringRef ( pointer . address ))

print ( "variant 4" )
let pm : Pointer [ __mlir_type . `!pop.scalar<si8>` ] = Pointer ( hello . data ())
print ( StringRef ( pm . address ))

print ( "variant 5" )
print ( String ( pointer . address ))

print ( "variant 6" )
let x = Buffer [ 8 , DType . int8 ]( pointer )
let array = x . simd_load [ 10 ]( 0 )
var result = String ()
for i in range ( len ( array )):
    result += chr ( array [ i ]. to_int ())
print ( result )

Mojo Playground 的代码共享

1. 在 Mojo Playground 中， right click资源管理器中的文件，然后按Open With > Editor
2. 在编辑器中右键单击， select all并copy
3. 创建新的 GitHub gist 或将 Jupyter Notebook 文件放入您的 GitHub 存储库
4. 粘贴内容并使用 Jupyter 扩展名命名文件，例如 test .ipynb
5. 将链接粘贴到 Discord 聊天中的要点

Github 正确地呈现了它，然后如果有人想在他们的 Playground 中尝试代码，他们可以复制粘贴原始代码。

Mojo 的禅宗

• Mojo 代码风格指南。魔精禅#141

改进空间

这是我个人的观点，所以不要太严厉地评价我。

我不能说 Mojo 是一种易于学习的编程语言，就像 Python 一样。

它需要对任何其他编程语言有大量的理解、耐心和经验。

如果你想构建一些不平凡的东西，那会很困难但很有趣！

距离我踏上这段旅程已经两周了，我很高兴地告诉大家，我现在已经熟悉了Mojo。

它错综复杂的结构和语法已经开始在我眼前解开，我充满了新的理解。

我很自豪地说，我现在可以自信地用这种语言编写代码，使我能够将各种各样的想法变成现实。

主要需要改进的地方：

1. 文档薄弱且不明确。
2. 缺乏代码示例。 clojuredocs 网站就是一个很好的例子。
3. 对语言范式的更多解释
4. 缺乏与 Python 基本事物数据类型/函数/类/表达式的比较。
5. 尽管Mojo是Python的超集，但语言入门的门槛并不是那么简单。
6. 有点生涩，需要一些时间来稳定语言。生产版本 1.0。
7. 虫子，就像任何虫子一样。
8. 小型标准库。
9. 项目 Jupyter 和笔记本环境。我知道 Jupyter 插件和自定义内核是一个很好的解决方案，但它使开发变得如此缓慢。
10. 还没有开源。社区正在等待开源编译器和 REPL 开始开发和生成库和应用程序。我认为社区将轻松地将（引导）编译器从 C++ 重写为 Mojo 本身。

很好，很适合获胜

1. 模块化团队轻松回应请求/问题/信件/想法
2. 友好且非常聪明的社区
3. 解决问题的编程语言，其理念不是创建新语法，而是应对实际挑战。
4. 我不知道你怎么想，但我一直在等待和研究 Mojo。我已经尝试过一百种编程语言。世界已准备好迎接计算和人工智能的革命和未来。我真的很喜欢 Mojo，它让我兴奋、着迷，我希望它对你也有同样的作用。
5. 我相信一位著名的杰出领袖博士。计算机科学 Chris Lattner 可以构建事物、系统、团队并改变未来。

模块化和 Mojo 的历史和词源

Mojo 是一种 Modular Inc 编程语言。为什么我们在这里讨论Mojo 。关于这家公司我们了解较少，但它有一个很酷的名字Modular ，可以参考：

• 模运算
• 模数
• 模块化编程
• 模块化

“换句话来说：Mojo 不是魔法，它是模块化的。”

关于计算、编程、AI/ML 的所有内容。一个非常好的域名，准确地描述了公司的含义。

还有一些关于 Modular 品牌故事和通过品牌帮助 Modular 实现 AI 人性化的附加材料

附加材料

• 克里斯·拉特纳
• LLVM
• MLIR
• 电路 IR 编译器和工具
• 交叉编译编译器-rt
• 人工智能的未来取决于模块化
• 开源应用程序LLVM的架构
• 硬件/软件协同设计时代的编译器设计黄金时代 作者：Chris Lattner 博士
• 100 秒了解 LLVM
• 魔力道场
• Mojo 备忘单
• 在 Mojo 中使用 SIMD 计算字符
• 编程语言的历史

MLIR 和低级实施

• 强力氧
• 索引操作
• LLVM 库
• GNU 库
• GNU libc 索引

Python / C++

• 麻木
• Numba 基于 (LLVM)
• 吡啶
• 基于Google JAX（XLA）
  • 自动梯度
  • XLA
• 射线
• 太极郎
  • 太极与幼崽丘比南巴的比较
• 密码子
  • 密码子基准
• 吡啶亚铜
• 赛通
• 毕斯兰
• Mypyc
• 努特卡
• 深速
• CPU 和 GPU 性能基准高性能 Python 库
• 元流
• 使用 mlops 加速实验
• 星雾艾
• Python 字节码的 Numba 编译器，Numba IR 转换为 LLVM IR，将 LLVM IR 编译为机器代码

人工智能

• 加速计算
• ONNX 机器学习开放标准
• ONNX Runtime：跨平台、高性能机器学习推理和训练加速器
• CUDA
• OpenCL
• SYCL
• 谷歌大脑 TensorFlow
• 火炬
• 张量RT
• OpenaAI Triton 语言和编译器
• 用机器学习制造
• 顶点人工智能
• 谷歌TPU
• 贤者
• MLIR：利用开源基础设施加速人工智能
• 阿帕奇TVM

Python提示

今天我想讲一个关于Python Enum 问题的故事。作为软件工程师我们经常在WEB中遇到它。假设我们有这个数据库模式（PostgreSQL），状态enum ：

 CREATE TYPE public .status_type AS ENUM (
    ' FIRST ' ,
    ' SECOND '
);

在 Python 代码中，我们需要字符串形式的名称和值（假设我们在前端使用带有某种 ENUM 类型的 GraphQL），并且我们需要维护它们的顺序并能够比较这些枚举：

order2.status > order1.status > 'FIRST'

所以这对于大多数常见语言来说都是一个问题 =) 但我们可以使用一个little-known Python 功能并覆盖枚举类方法： __new__ 。

• 但为什么？
• 嗯..将每个枚举值与其索引相关联！ MALE -> 1 ， FEMALE -> 2 ，就像 PostgreSQL 那样。
• 以及如何？
• 只需使用len函数计算其成员即可！

 import enum
from functools import total_ordering


@ total_ordering
@ enum . unique
class BaseUniqueSortedEnum ( enum . Enum ):
    """Base unique enum class with ordering."""

    def __new__ ( cls , * args , ** kwargs ):
        obj = object . __new__ ( cls )
        obj . index = len ( cls . __members__ ) + 1  # This code line is a piece of advice, an insight and a tip!
        return obj

    # and then boring Python's magic methods as usual...

    def __hash__ ( self ) -> int :
        return hash (
          f" { self . __module__ } _ { self . __class__ . __name__ } _ { self . name } _ { self . value } "
        )

    def __eq__ ( self , other ) -> bool :
        self . _check_type ( other )
        return super (). __eq__ ( other )

    def __lt__ ( self , other ) -> bool :
        self . _check_type ( other )
        return self . index < other . index

    def _check_type ( self , other ) -> None :
        if type ( self ) != type ( other ):
            raise TypeError ( f"Different types of Enum: { self } != { other } " )


class Dog ( BaseUniqueSortedEnum ):
    # THIS ORDER MATTERS!
    BLOODHOUND = "BLOODHOUND"
    WEIMARANER = "WEIMARANER"
    SAME = "SAME"


class Cat ( BaseUniqueSortedEnum )
    # THIS ORDER MATTERS!
    BRITISH = "BRITISH"
    SCOTTISH = "SCOTTISH"
    SAME = "SAME"


# and some tests
assert Dog . BLOODHOUND < Dog . WEIMARANER
assert Dog . BLOODHOUND <= Dog . WEIMARANER
assert Dog . BLOODHOUND != Dog . WEIMARANER
assert Dog . BLOODHOUND == Dog . BLOODHOUND
assert Dog . WEIMARANER == Dog . WEIMARANER
assert Dog . WEIMARANER > Dog . BLOODHOUND
assert Dog . WEIMARANER >= Dog . BLOODHOUND

assert Cat . BRITISH < Cat . SCOTTISH
assert Cat . BRITISH <= Cat . SCOTTISH
assert Cat . BRITISH != Cat . SCOTTISH
assert Cat . BRITISH == Cat . BRITISH
assert Cat . SCOTTISH == Cat . SCOTTISH
assert Cat . SCOTTISH > Cat . BRITISH
assert Cat . SCOTTISH >= Cat . BRITISH

assert hash ( Dog . BLOODHOUND ) == hash ( Dog . BLOODHOUND )
assert hash ( Dog . WEIMARANER ) == hash ( Dog . WEIMARANER )
assert hash ( Dog . BLOODHOUND ) != hash ( Dog . WEIMARANER )
assert hash ( Dog . SAME ) != hash ( Cat . SAME )

# raise TypeError
Dog . SAME <= Cat . SAME
Dog . SAME < Cat . SAME
Dog . SAME > Cat . SAME
Dog . SAME >= Cat . SAME
Dog . SAME != Cat . SAME

故事的结局。并使用这个Python ENUM见解来进行良好的编码！

贡献

• 随时欢迎您的贡献！
• 如果您有任何疑问，请随时与我联系。
• 如果您想参与 MojoDriven 社区倡议，请与我联系。
• 您对支持此存储库的帮助