
Rustでエラーがでたときに下のように「注意: バックトレースを表示するために環境変数`RUST_BACKTRACE=1`をつけて実行しろよ」ってメッセージがでる。

```bash
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
# 注意: バックトレースを表示するために環境変数`RUST_BACKTRACE=1`をつけて実行しろよ
```

いくつかの環境で`RUST_BACKTRACE=1`を設定するコマンドを載せます。

以下は実行したプロセス内だけ有効な設定方法です。
環境変数を永続化する方法は検索してください。

## Contents

## Windows コマンドプロンプト

```bash
set RUST_BACKTRACE=1
```

## Windows パワーシェル

```bash
$env:RUST_BACKTRACE=1
```

## Mac OS X

```bash
export RUST_BACKTRACE=1
```

## Linux

```bash
RUST_BACKTRACE=1

# 表示
echo $RUST_BACKTRACE

# 削除
unset RUST_BACKTRACE


# 環境変数を使いつつ実行する
env RUST_BACKTRACE=1 cargo run
```

## バックトレースの例

Windows PowerShellで実行した例です。

```bash
> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.16s
     Running `target\debug\opengl.exe`
OK: init OpenGL: version=3.1
thread 'main' panicked at 'failed to open file: rsc/shader/shader.vs', src\shader.rs:29:33
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\opengl.exe` (exit code: 101)
```

「注意: バックトレースを表示するために環境変数`RUST_BACKTRACE=1`をつけて実行しろよ」ってメッセージ。
その手前の行でエラーが起きた行とエラー内容がわかるが、バックトレースをつけてもう一度実行する。

### RUST_BACKTRACE=1

`RUST_BACKTRACE=1`をつけて実行する。

```bash
> $env:RUST_BACKTRACE=1
> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target\debug\opengl.exe`
OK: init OpenGL: version=3.1
thread 'main' panicked at 'failed to open file: rsc/shader/shader.vs', src\shader.rs:29:33
stack backtrace:
   0: std::panicking::begin_panic_handler
             at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:493
   1: std::panicking::begin_panic_fmt
             at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:435
   2: opengl::shader::{{impl}}::new::{{closure}}
             at .\src\shader.rs:29
   3: core::result::Result<std::fs::File, std::io::error::Error>::unwrap_or_else<std::fs::File,std::io::error::Error,closure-0>
             at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\result.rs:825
   4: opengl::shader::Shader::new
             at .\src\shader.rs:28
   5: opengl::main
             at .\src\main.rs:53
   6: core::ops::function::FnOnce::call_once<fn(),tuple<>>
             at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:227
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
error: process didn't exit successfully: `target\debug\opengl.exe` (exit code: 101)
```

作成したプログラムの`.\src\shader.rs:29`で呼び出しているstdのクレートの中まで追ってパニックが起きた個所を特定出来た。

クレートの中まで追ってエラー原因を特定したいときには、バックトレースを表示する。
バックトレースが表示できどんな内容か把握したので、今後エラーメッセージだけで分からないときに原因を追えるようになった。

### RUST_BACKTRACE=full

`RUST_BACKTRACE=1`でバックトレースを表示すると、さらに`RUST_BACKTRACE=full`の設定があることも表示された。
試してみる。

```bash
# 数値ではなく文字列なので"で囲っている
> $env:RUST_BACKTRACE="full"

> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.14s
     Running `target\debug\opengl.exe`
OK: init OpenGL: version=3.1
thread 'main' panicked at 'failed to open file: rsc/shader/shader.vs', src\shader.rs:29:33
stack backtrace:
   0:     0x7ff7e19b68ae - std::backtrace_rs::backtrace::dbghelp::trace
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\..\..\backtrace\src\backtrace\dbghelp.rs:98
   1:     0x7ff7e19b68ae - std::backtrace_rs::backtrace::trace_unsynchronized
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\..\..\backtrace\src\backtrace\mod.rs:66
   2:     0x7ff7e19b68ae - std::sys_common::backtrace::_print_fmt
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\sys_common\backtrace.rs:67
   3:     0x7ff7e19b68ae - std::sys_common::backtrace::_print::{{impl}}::fmt
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\sys_common\backtrace.rs:46
   4:     0x7ff7e19c9c3b - core::fmt::write
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\core\src\fmt\mod.rs:1078
   5:     0x7ff7e19b3f48 - std::io::Write::write_fmt<std::sys::windows::stdio::Stderr>
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\io\mod.rs:1517
   6:     0x7ff7e19b928d - std::sys_common::backtrace::_print
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\sys_common\backtrace.rs:49
   7:     0x7ff7e19b928d - std::sys_common::backtrace::print
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\sys_common\backtrace.rs:36
   8:     0x7ff7e19b928d - std::panicking::default_hook::{{closure}}
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:208
   9:     0x7ff7e19b8cf4 - std::panicking::default_hook
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:225
  10:     0x7ff7e19b9b9e - std::panicking::rust_panic_with_hook
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:591
  11:     0x7ff7e19b96c1 - std::panicking::begin_panic_handler::{{closure}}
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:497
  12:     0x7ff7e19b720f - std::sys_common::backtrace::__rust_end_short_backtrace<closure-0,!>
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\sys_common\backtrace.rs:141
  13:     0x7ff7e19b9619 - std::panicking::begin_panic_handler
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:493
  14:     0x7ff7e19b95cc - std::panicking::begin_panic_fmt
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:435
  15:     0x7ff7e19745a8 - opengl::shader::{{impl}}::new::{{closure}}
                               at C:\git\trial-code\rust\opengl\src\shader.rs:29
  16:     0x7ff7e1978cc5 - core::result::Result<std::fs::File, std::io::error::Error>::unwrap_or_else<std::fs::File,std::io::error::Error,closure-0>
                               at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\result.rs:825
  17:     0x7ff7e1976af5 - opengl::shader::Shader::new
                               at C:\git\trial-code\rust\opengl\src\shader.rs:28
  18:     0x7ff7e1974e23 - opengl::main
                               at C:\git\trial-code\rust\opengl\src\main.rs:53
  19:     0x7ff7e19735eb - core::ops::function::FnOnce::call_once<fn(),tuple<>>
                               at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:227
  20:     0x7ff7e1973e9b - std::sys_common::backtrace::__rust_begin_short_backtrace<fn(),tuple<>>
                               at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\sys_common\backtrace.rs:125
  21:     0x7ff7e1979591 - std::rt::lang_start::{{closure}}<tuple<>>
                               at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\rt.rs:66
  22:     0x7ff7e19b9d54 - core::ops::function::impls::{{impl}}::call_once
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\library\core\src\ops\function.rs:280
  23:     0x7ff7e19b9d54 - std::panicking::try::do_call
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:379
  24:     0x7ff7e19b9d54 - std::panicking::try
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panicking.rs:343
  25:     0x7ff7e19b9d54 - std::panic::catch_unwind
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\panic.rs:396
  26:     0x7ff7e19b9d54 - std::rt::lang_start_internal
                               at /rustc/cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\/library\std\src\rt.rs:51
  27:     0x7ff7e1979563 - std::rt::lang_start<tuple<>>
                               at C:\Users\suzu6\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\rt.rs:65
  28:     0x7ff7e1975660 - main
  29:     0x7ff7e19cf2f4 - invoke_main
                               at D:\a01\_work\9\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:78
  30:     0x7ff7e19cf2f4 - __scrt_common_main_seh
                               at D:\a01\_work\9\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288
  31:     0x7ffa9a4a7034 - BaseThreadInitThunk
  32:     0x7ffa9c422651 - RtlUserThreadStart
error: process didn't exit successfully: `target\debug\opengl.exe` (exit code: 101)
```

## 参考

- [いまさらですがLinuxで環境変数を設定したい](https://qiita.com/chihiro/items/bb687903ee284766e879)


【Rust】エラーが出たときの RUST_BACKTRACE=1 を設定する


Rust の num クレートのサンプルです。
さらっとどんなものがあるか把握できるような形式で書いていきます。
網羅してません。

## 概要

num は Rust の数値型と traits のコレクションです。

これには、大きな整数、有理数(別名：分数)、複素数のための新しい型、Integerのような数値プロパティの一般的なプログラミングのための新しいtrait、および一般的な範囲イテレータが含まれます。

- **num** <https://crates.io/crates/num>
- [Documentation](https://docs.rs/num/0.4.0/num/)
- [Repository](https://github.com/rust-num/num)

num はメタクレートであり、これらのサブクレートからアイテムを再エクスポートします。

- [num-bigint](https://crates.io/crates/num-bigint)
- [num-complex](https://crates.io/crates/num-complex)
- [num-integer](https://crates.io/crates/num-integer)
- [num-iter](https://crates.io/crates/num-iter)
- [num-rational](https://crates.io/crates/num-rational)
- [num-traits](https://crates.io/crates/num-traits)
- ([num-derive](https://crates.io/crates/num-derive))

※ ここまで直訳です。

## Contents

## バージョンと利用方法

```toml:Cargo.toml
[dependencies]
num = "0.4"
```

AtCoderでは `num = "=0.2.1"`が利用可能です
[Language Test 202001](https://atcoder.jp/contests/language-test-202001)。

## 整数の割り算とあまり

```rust
extern crate num;
use num::integer;

fn main() {
    // 割り切れないとき
    assert_eq!(integer::div_floor(7, 3), 2);
    assert_eq!(integer::div_ceil(7, 3), 3);

    // 割り切れる場合はどちらも同じ
    assert_eq!(integer::div_floor(6, 3), 2);
    assert_eq!(integer::div_ceil(6, 3), 2);
}
```

小数を`foor`では切り捨て、`ceil`では切り上げる。

```rust
// 11 わる 3 = 3 あまり 2
// Simultaneous floored integer division and modulus
assert_eq!(integer::div_mod_floor(11, 3), (3, 2));
// Simultaneous integer division and modulus
assert_eq!(integer::div_rem(11, 3), (3, 2));
```

どちらも符号が同じ整数の場合は二つの違いは特にない。
符号が異なる場合に結果に相違がある。

[【Rust】num-integerのdiv_mod_floor()とdiv_rem()の違い](https://www.suzu6.net/posts/293-rust-num-integer-div/)に実装と論文の引用をまとめた。

## 根

```rust
use num::integer;
use num::Float;
// sqrt(x) x^(1/2)
assert_eq!(integer::sqrt(2), 1);
assert_eq!(Float::sqrt(2.0), 1.4142135623730951);
assert_eq!(integer::sqrt(3), 1);
assert_eq!(Float::sqrt(3.0), 1.7320508075688772);

// cbrt(x) x^(1/3)
assert_eq!(integer::cbrt(2), 1);
assert_eq!(Float::cbrt(2.0), 1.259921049894873);

// nth_root(x, n) x^(1/n)
assert_eq!(integer::nth_root(16, 5), 1);
```

`sqrt`は2乗根、`cbrt`は3乗根です。
`nth_root()`はintegerのみ。

Integerでは小数が切り捨てられる。

## 乗数

```rust
// exp(x) e^x
assert_eq!(Float::exp(2.0), 7.38905609893065);

// exp2(x) 2^x
assert_eq!(Float::exp2(2.0), 4.0);
```

## 対数

```rust
// ln(x) log_e(x)
assert_eq!(Float::ln(2.0), 0.6931471805599453);

// log(x, base) log_base(x)
assert_eq!(Float::log(2.0, 3.0), 0.6309297535714574);
```

## 複素数

```rust
use num::Complex;

// 複素数
let z = Complex { re: 2.0, im: -1.0 };
assert_eq!(
    z * z,
    Complex { re: 3.0, im: -4.0 }
);
```

[【Rust】並列処理でマンデルブロ集合の画像を作るコード](https://www.suzu6.net/posts/290-rust-mandelbrot/)でも複素数を使っています。

## 最大公約数と最小公倍数

```rust
// gcd 最大公約数
assert_eq!(integer::gcd(12, 18), 6);

// lcm 最小公倍数
assert_eq!(integer::lcm(12, 18), 36);
```

## 二項係数

```rust
// Binomial Coefficient n!/(k!*(n-k)!)
assert_eq!(integer::binomial(10, 3), 120);
```


Rustのnumクレートの実行サンプル


引数が正の整数の場合はどちらも返り値が同じ。
引数がどちらも負の数を渡した場合も返り値が同じ。

違いは２つの引数の符号が異なる場合に現れる。

## どちらも正の整数

div_mod_floor() と div_rem() はどちらも `(商, あまり)` のタプルを返します。

```rust
// 11 わる 3 = 3 あまり 2
// Simultaneous floored integer division and modulus
assert_eq!(integer::div_mod_floor(11, 3), (3, 2));
// Simultaneous integer division and modulus
assert_eq!(integer::div_rem(11, 3), (3, 2));
```

どちらも正の整数の場合は二つの違いは特にない。


## どちらも負の整数

負の整数を渡しても返り値に相違はない。

```rust
// -11 わる -3
assert_eq!(integer::div_mod_floor(-11, -3), (3, -2));
assert_eq!(integer::div_rem(-11, -3), (3, -2));

// -17 わる -5
assert_eq!(integer::div_mod_floor(-17, -5), (3, -2));
assert_eq!(integer::div_rem(-17, -5), (3, -2));
```


## 二つの引数の符号が異なる場合

ただし、２つの引数の符号が異なる場合には相違がある。

```rust
// -11 わる 3
assert_eq!(integer::div_mod_floor(-11, 3), (-4, 1));
assert_eq!(integer::div_rem(-11, 3), (-3, -2));

// 11 わる -3
assert_eq!(integer::div_mod_floor(11, -3), (-4, -1));
assert_eq!(integer::div_rem(11, -3), (-3, 2));
```

- div_rem() の場合は `div_rem(-11, 3) == div_rem(-11, -3)`です。
- div_mod_floor() の場合は `div_mod_floor(-11, 3) != div_mod_floor(-11, -3)`である。

## div_mod_floor() と div_rem() のコード

なぜ、div_mod_floor()が上のようになっているかはコードを見るとわかる。
`div_mod_floor()`では符号が異なる場合に明示的な処理をしている。

https://github.com/rust-num/num-integer/blob/master/src/lib.rs

```rust:lib.rs
/// Calculates `div_floor` and `mod_floor` simultaneously
#[inline]
fn div_mod_floor(&self, other: &Self) -> (Self, Self) {
    // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
    // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
    let (d, r) = self.div_rem(other);
    if (r > 0 && *other < 0) || (r < 0 && *other > 0) {
        (d - 1, r + *other)
    } else {
        (d, r)
    }
}

/// Simultaneous truncated integer division and modulus.
#[inline]
fn div_rem(&self, other: &Self) -> (Self, Self) {
    (*self / *other, *self % *other)
}
```

コードのコメントの[論文](https://www.microsoft.com/en-us/research/publication/division-and-modulus-for-computer-scientists/?from=http%3A%2F%2Fresearch.microsoft.com%2Fpubs%2F151917%2Fdivmodnote-letter.pdf)より抜粋。

> F-division floors the quotient and effectively rounds toward negative infinity.
> This definition is described by Knuth (Knuth, 1972) and is used by Oberon (Wirth, 1988) and Haskell (Peyton Jones and Hughes (eds.), 1998). Note that the sign of the modulus is always the same as the sign of the divisor. F-division is also a sign-preserving division (Boute, 1992), i.e. given the signs of the quotient and remainder, we can give the signs of the dividend and divisor. Floored division can be expressed in terms of truncated division.
> 
> F-divisionは商をフロア化し、効果的に負の無限大に向かって丸めます。
> この定義は、Knuth (Knuth, 1972) によって記述され、Oberon (Wirth, 1988) および Haskell (Peyton Jones and Hughes (eds.), 1998) で使用されています。なお、モジュラスの符号は、常に除数の符号と同じです。F-divisionは符号保存除算でもあります(Boute, 1992)。すなわち、商と剰余の符号が与えられれば、配当と除数の符号を与えることができます。フロアー式除算は、切り捨て式除算で表現することができます。
> 
> Algorithm F:
> $$
> q_F = q_T − I \\
> r_F = r_T + I · d
> $$
> where
> $$
> I = if signum(r_T) = −signum(d) then 1 else 0
> $$

[Daan Leijen. _Division and Modulus for Computer Scientists_, December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)

`div_mod_floor(11, -3) -> (-4, -1)`の例では`div_rem(11, -3) -> (-3, 2)`なので

$$
(-4 = -3 - 1, -1 = 2 + (-3))
$$
となる。

【Rust】num-integerのdiv_mod_floor()とdiv_rem()の違い


最近Rustを勉強しています。
体系的に学ぶためにO’ReillyのプログラミングRustを買いました。

![book](/images/posts/290/290/rust-book.jpg)

- [O'Reilly プログラミングRust](https://www.oreilly.co.jp/books/9784873118550/)
- [Amazon プログラミングRust](https://amzn.to/3ae6C90)

第２章のRustがどんな言語なのか体験するために書くコードが、まさかのマンデルブロ集合で驚きつつも楽しく取り組めました。

この記事では全ては説明しませんが、自分なりに重要なところとかをまとめます。

## Contents

## 何ができるようになったか

Rustでマンデルブロ集合の画像を描画するコードを書きながらRustについて学びました。
さらに、並列処理でレンダリングもしています。

完成すると、以下のコマンドでマンデルブロ集合の画像を出力します。

```bash
# ビルドした実行ファイル 画像ファイル名　サイズ 左上複素数　右下複素数
$ mandelbrot.exe  mandelbrot.png 1000x750 -1.20,0.35 -1,0.20
```

出力
![mandelbrot](/images/posts/290/290/mandelbrot.png)

8ビットのグレイスケールですが模様と淡いグレイが大理石っぽくて綺麗です！

## マンデルブロ集合について

マンデルブロ集合（Mandelbrot set）は拡大していくと似たようなモノが繰り返し現れるフラクタルとしても有名で、拡大していく映像はYouTubeでも結構再生されてて人気です。「神の指紋」とも呼ばれている[^2]。

↓4Kの解像度のまま１時間かけて拡大していく超大作。無限に見てられる。
<iframe width="560" height="315" src="https://www.youtube.com/embed/pCpLWbHVNhk" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

マンデルブロ集合は次の漸化式

$$
{\displaystyle
  {\begin{cases}
    z_{n+1}=z_{n}^{2}+c\\z_{0}=0
  \end{cases}}
}
$$

で定義される複素数列 ${z_n}$ $n∈N∪{0}$が $n → ∞$ の極限で無限大に発散しないという条件を満たす複素数 $c$ 全体が作る集合がマンデルブロ集合である[^1]。

式を展開するとこんな感じ。
$$
z_{n+1}=z_{n}^{2}+c\\
z_{n+1}={(Re_n+Im_n)}^{2}+c\\
z_{n+1}={(a+bi)}^{2}+c\\
z_{n+1}={a}^{2}-{b}^{2}+2abi+c
$$

iは$\sqrt{-1}=i$の複素数です。
$z_{n+1}={a}^{2}-{b}^{2}+2abi+c$となって$z$が無限大に発散していくが、その速度は複素数によって異なります。
Rustでは`num::Complex`のクレートを使っているため、複素数の計算も`z * z`と簡潔に書けます。

画像にするときには横軸を実数、縦軸を虚数と見立て画素の座標における複素数について発散（または一定回数）まで繰り返し計算を求めます。
発散するまでの計算回数を画像の濃淡として表すと、このような美しい模様になります。

参考

- マンデルブロ集合とは <https://azisava.sakura.ne.jp/mandelbrot/definition.html↩>
- [フラクタル] マンデルブロー集合 10の200乗倍への挑戦 <http://elephnote.com/blog/archives/586>

[^1]: [マンデルブロ集合とは](https://azisava.sakura.ne.jp/mandelbrot/definition.html)
[^2]: [MATH ART マス・アート~真理,美,そして方程式](https://amzn.to/3e8oB1w)

## コード

コードはクレートのバージョンを新しくしたため、書籍のサンプルとはすこし異なります。
書籍は2018年の第2刷です。

書籍のサンプルから以下の点を変更しています。

- クレートを最新化した
- 並列処理のクレートを crossbeamからrayonに変更した

書いたコードのリポジトりはこちら <https://github.com/suzu6/trial-code/tree/master/rust/algorithms/mandelbrot>

コードは最終的にO'Reillyのリポジトリにあったものに寄せました。

> Code examples for the book Programming Rust, from O'Reilly
> <https://github.com/ProgrammingRust/mandelbrot>

### クレートのバージョン

```yml:Cargo.toml
[dependencies]
# I update to latest version crate.
num = "0.4.0"      # <- 0.1.27
image = "0.23.14"  # <- 0.13.0
rayon = "1.5.0"    # <- crossbeam=0.2.8
```

O’Reillyのリポジトリでは並列処理が[crossbeam](https://crates.io/crates/crossbeam)から[rayon](https://crates.io/crates/rayon)に変わってました。

### main(): 処理の流れ

全て一つのファイルに書いているので少し長めです。
個人的にメイン関数が一番上にあって実行する順に関数があると全体を把握しやすいのでそう並べています。
関数でわけて補足していきます。

全体の処理の流れは以下の通りです。

1. 引数の受け取り
2. 引数から画像サイズと複素空間の位置の情報をパースする
3. マンデルブロ集合の計算
   1. 直列または並列処理
4. 計算結果を画像として書き出す

```rust:main.rs
use std::io::Write;

fn main() {
    let args: Vec<String> = std::env::args().collect();

    if args.len() != 5 {
        writeln!(
            std::io::stderr(),
            "Usage: mandelbrot FILE PIXELS UPPERLEFT LOWERRIGHT"
        )
        .unwrap();
        writeln!(
            std::io::stderr(),
            "Example: {} mandel.png 1000x750 -1.20,0.35 -1,0.20",
            args[0]
        )
        .unwrap();
        std::process::exit(1);
    }

    let bounds = parse_pair(&args[2], 'x').expect("error parsing image dimensions");
    let upper_left = parse_complex(&args[3]).expect("error parsing upper left corner point");
    let lower_right = parse_complex(&args[4]).expect("error parsing lower right corner point");


    // Single thread rendering;
    let pixels = single_thread_render(bounds, upper_left, lower_right);
    write_image("no_thread.png", &pixels, bounds).expect("error writing PNG file");

    // Multi thread rendering;
    let pixels = multi_threads_render(bounds, upper_left, lower_right);
    write_image(&args[1], &pixels, bounds).expect("error writing PNG file");
}
```

引数は`<ファイル名> <画像サイズ(widthxheight)> <複素数空間の左上(Re,Im)> <複素数空間の右下(Re,Im)>`と取っています。

```bash:引数の例
# Usage: mandelbrot FILE PIXELS UPPERLEFT LOWERRIGHT
$ cargo run mandel.png 1000x750 -1.20,0.35 -1,0.20
```

引数の数が合わない場合は処理の前に終了します。

```bash
# 引数が多い
> cargo run no_thread.png 500x500 1.0,0.0 -1.0,1.0 xxxx
   Compiling mandelbrot v0.1.0 (C:\git\trial-code\rust\algorithms\mandelbrot)
    Finished dev [unoptimized + debuginfo] target(s) in 2.31s
     Running `target\debug\mandelbrot.exe no_thread.png 500x500 1,0 -1.0,1 xxxx`
Usage: mandelbrot FILE PIXELS UPPERLEFT LOWERRIGHT
Example: target\debug\mandelbrot.exe mandel.png 1000x750 -1.20,0.35 -1,0.20
error: process didn't exit successfully: `target\debug\mandelbrot.exe no_thread.png 500x500 1,0 -1.0,1 xxxx`
(exit code: 1)
```

### parse_pair(): 引数のパース①

引数で受け取った画像サイズ`widthxheight`を区切り文字`x`で分けてタプル`()`で返します。

面白いのは返すタプルがジェネリック型になっているため`parse_pair::<i32>("10,20", ',')`で32ビット整数型、`parse_pair::<f64>("0.5x", 'x')`と書くと64ビット浮動小数点型のタプルが返ってきます。

返り値は`Option`です。
型のパースが出来なかった場合は`None`が返るため、その条件分岐を`match`で判定している。

```rust:parse_pair()
/// Parse the string `s` as a coordinate pair, like `"400x600"` or `"1.0,0.5"`.
///
/// Specifically, `s` should have the form <left><sep><right>, where <sep> is
/// the character given by the `separator` argument, and <left> and <right> are both
/// strings that can be parsed by `T::from_str`.
///
/// If `s` has the proper form, return `Some<(x, y)>`. If it doesn't parse
/// correctly, return `None`.
use std::str::FromStr;

fn parse_pair<T: FromStr>(s: &str, separator: char) -> Option<(T, T)> {
    match s.find(separator) {
        None => None,
        Some(index) => match (T::from_str(&s[..index]), T::from_str(&s[index + 1..])) {
            (Ok(l), Ok(r)) => Some((l, r)),
            _ => None,
        },
    }
}

#[test]
fn test_parse_pair() {
    assert_eq!(parse_pair::<i32>("", ','), None);
    assert_eq!(parse_pair::<i32>("10,", ','), None);
    assert_eq!(parse_pair::<i32>(",10", ','), None);
    assert_eq!(parse_pair::<i32>("10,20", ','), Some((10, 20)));
    assert_eq!(parse_pair::<i32>("10,20xy", ','), None);
    assert_eq!(parse_pair::<f64>("0.5x", 'x'), None);
    assert_eq!(parse_pair::<f64>("0.5x1.5", 'x'), Some((0.5, 1.5)));
}
```

テストもこのように書くことができる。

引数のパースに失敗した場合は`None`が返るため、その後の処理で型が合わず`panic`が起きて終了します。
型があると何行目でどの引数で失敗したか示されてデバッグがしやすいですね。

```bash
# パースに失敗した場合
$ cargo run no_thread.png 500x500 1.0,0.0 -1.0,1.0s
    Finished dev [unoptimized + debuginfo] target(s) in 0.12s
     Running `target\debug\mandelbrot.exe no_thread.png 500x500 1,0 -1.0,1.0s`
thread 'main' panicked at 'error parsing lower right corner point', src\main.rs:23:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\mandelbrot.exe no_thread.png 500x500 1,0 -1.0,1.0s` (exit code: 101)
```

### parse_complex(): 引数のパース②

`parse_pair()`をラップして`f64,f64`に対応した関数。
タプル`(f64, f64)`から`Comlex<f64>`への変換もしています。

```rust
extern crate num;
use num::Complex;

// Parse a pair of floating-point numbers separated by a comma as a complex number.
fn parse_complex(s: &str) -> Option<Complex<f64>> {
    match parse_pair(s, ',') {
        Some((re, im)) => Some(Complex { re, im }),
        None => None,
    }
}

#[test]
fn test_parse_complex() {
    assert_eq!(
        parse_complex("1.25,-0.00625"),
        Some(Complex {
            re: 1.25,
            im: -0.00625
        })
    );
    assert_eq!(parse_complex(", -0.00625"), None);
}
```

### pixel_to_point(): 画素から複素平面の座標への写像

画像と複素数の二つの空間を対応させる必要があります。
この関数では画素から複素平面の座標への写像です。

虚部の計算が引き算になっているのは、上に点が動くと画素は高さが増えるが虚部は減るためです。

```rust:pixel_to_point()
/// Given the row and column of a pixel in the output image, return the
/// corresponding point on the complex plane.
///
/// `bounds` is a pair giving the width and height of the image in pixels.
/// `pixel` is a (column, row) pair indicating a particular pixel in that image.
/// The `upper_left` and `lower_right` parameters are points on the complex
/// plane designating the area our image covers.
fn pixel_to_point(
    bounds: (usize, usize),
    pixel: (usize, usize),
    upper_left: Complex<f64>,
    lower_right: Complex<f64>,
) -> Complex<f64> {
    let (width, height) = (
        lower_right.re - upper_left.re,
        upper_left.im - lower_right.im,
    );
    Complex {
        re: upper_left.re + pixel.0 as f64 * width / bounds.0 as f64,
        im: upper_left.im - pixel.1 as f64 * height / bounds.1 as f64,
    }
}

#[test]
fn test_pixel_to_point() {
    assert_eq!(
        pixel_to_point(
            (100, 100),
            (25, 75),
            Complex { re: -1.0, im: 1.0 },
            Complex { re: 1.0, im: -1.0 }
        ),
        Complex { re: -0.5, im: -0.5 }
    );
}
```

### single_thread_render()とrender(): レンダリング

こちらはシングルスレッドでレンダリングをしています。

`render()`に渡すpixelsは参照渡しであり、画素ごとに独立して計算できるため並列に毛産することも可能です。
後で並列の関数を紹介します。

```rust:single_thread_render()
fn single_thread_render(
    bounds: (usize, usize),
    upper_left: Complex<f64>,
    lower_right: Complex<f64>
) -> Vec<u8> {
    let mut pixels = vec![0; bounds.0 * bounds.1];
    render(&mut pixels, bounds, upper_left, lower_right);

    pixels
}

/// Render a rectangle of the Mandelbrot set into a buffer of pixels.
///
/// The `bounds` argument gives the width and height of the buffer `pixels`,
/// which holds one grayscale pixel per byte. The `upper_left` and `lower_right`
/// arguments specify points on the complex plane corresponding to the upper-
/// left and lower-right corners of the pixel buffer.
fn render(
    pixels: &mut [u8],
    bounds: (usize, usize),
    upper_left: Complex<f64>,
    lower_right: Complex<f64>,
) {
    assert!(pixels.len() == bounds.0 * bounds.1);

    for row in 0..bounds.1 {
        for column in 0..bounds.0 {
            let point = pixel_to_point(bounds, (column, row), upper_left, lower_right);
            pixels[row * bounds.0 + column] = match escape_time(point, 255) {
                None => 0,
                Some(count) => 255 - count as u8,
            };
        }
    }
}
```

### escape_time(): 漸化式とリミット

マンデルブロ集合の画像を作るためには、画像上のすべての画素に対する複素平面上の点が発散するまでの計算回数をカウントする必要がある。
グレイスケールは8bitの画素で表現できるため、今回limitには255を受け取る。

```rust

#[allow(dead_code)]
fn escape_time(c: Complex<f64>, limit: u32) -> Option<u32> {
    let mut z = Complex { re: 0.0, im: 0.0 };
    for i in 0..limit {
        z = z * z + c;
        if z.norm_sqr() > 4.0 {
            return Some(i);
        }
    }

    None
}
```

`z.norm_sqr()`は複素数のノルム（絶対値）を求めている。

### write_image(): 画像への書き出し

8ビットの２次元配列を画像として出力します。
[iamge](https://crates.io/crates/image)クレートを利用してpngのグレイスケールの画像を書き出します。

```rust:write_image()

extern crate image;
use image::png::PngEncoder;
use image::ColorType;
use std::fs::File;

/// Write the buffer `pixels`, whose dimensions are given by
/// `bounds`, to the file named `filename`.
fn write_image(
    filename: &str,
    pixels: &[u8],
    bounds: (usize, usize),
) -> Result<(), image::ImageError> {
    let output = File::create(filename)?;

    let encoder = PngEncoder::new(output);
    let result = encoder.encode(&pixels, bounds.0 as u32, bounds.1 as u32, ColorType::L8);
    match result {
        Ok(()) => {
            return Ok(());
        }
        Err(e) => {
            return Err(e);
        }
    }
}

```

### multi_threads_render(): 並列処理

[rayon](https://crates.io/crates/rayon)を使って並列に画素のレンダリングをします。

`pixels`は画像の左上から右下までを順に並べた1次元配列です。
これを`pixels.chunks_mut(bounds.0)`で画像の幅毎に配列を切り分けて、２次元の配列にします。
この幅毎に分けてそれぞれ並列に計算していきます。

[std::vec::Vec::chunks_mut](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.chunks_mut)

```rust
use rayon::prelude::*;

fn multi_threads_render(
    bounds: (usize, usize),
    upper_left: Complex<f64>,
    lower_right: Complex<f64>
) -> Vec<u8> {
    let mut pixels = vec![0; bounds.0 * bounds.1];
    // Scope of slicing up `pixels` into horizontal bands.
    {
        let bands: Vec<(usize, &mut [u8])> = pixels.chunks_mut(bounds.0).enumerate().collect();

        bands.into_par_iter().for_each(|(i, band)| {
            let top = i;
            let band_bounds = (bounds.0, 1);
            let band_upper_left = pixel_to_point(bounds, (0, top), upper_left, lower_right);
            let band_lower_right =
                pixel_to_point(bounds, (bounds.0, top + 1), upper_left, lower_right);
            render(band, band_bounds, band_upper_left, band_lower_right);
        });
    }

    pixels
}
```


【Rust】並列処理でマンデルブロ集合の画像を作るコード


Rustnの**HashMap**を使って同じ要素をカウントして多い順に並べてみます。

## Contents

## HashMapについて

ハッシュマップはキーとそれに紐づいた値の対応関係を保持した構造です。
他の言語ではハッシュテーブルや連想配列などとも呼ばれています。

- [std::collections::HashMap](https://doc.rust-lang.org/std/collections/struct.HashMap.html)
- [キーとそれに紐づいた値をハッシュマップに格納する - The Rust Programming Language 日本語版](https://doc.rust-jp.rs/book-ja/ch08-03-hash-maps.html?highlight=hashmap#%E6%96%B0%E8%A6%8F%E3%83%8F%E3%83%83%E3%82%B7%E3%83%A5%E3%83%9E%E3%83%83%E3%83%97%E3%82%92%E7%94%9F%E6%88%90%E3%81%99%E3%82%8B)

## 重複した要素のカウント

ベクトルにある数字をそれぞれカウントします。

```rust
use std::collections::HashMap;

fn main() {
    let vector = vec![1, 3, 4, 1, 2, 5, 2, 3, 4, 1, 3, 4, 1];
    // 要素ごとのカウント
    let mut hashmap = HashMap::new();
    for x in vector {
        let counter = hashmap.entry(x).or_insert(0);
        *counter += 1;
    }
    println!("{:?}", hashmap);
}
```

```txt:出力
{4: 3, 2: 2, 3: 3, 1: 4, 5: 1}
```

`let mut hashmap = HashMap::new();`でHashMapを初期化します。
後の処理で型が推測できます。

`.entry(x)`でキーを挿入しますが、`.entry(x).or_insert(0)`ではまだ存在しない場合にのみキーを挿入します。
`.or_insert(0)`は可変の値(`<K, V>`のV)の参照を返すため、`*counter += 1`のようにポインターで値を操作できます。

## 値の大きい順にソートする

ハッシュマップをカウントを降順にソートします。

```rust
// 先ほどカウントの続き

// カウント順にソート
let mut vector2: Vec<_> = hashmap.into_iter().collect();
vector2.sort_by(|x, y| y.1.cmp(&x.1));
println!("{:?}", vector2);
```

```txt:出力
[(1, 4), (3, 3), (4, 3), (2, 2), (5, 1)]
```

`hashmap.into_iter().collect();`でハッシュマップをタプルのベクトルに変換してから、タプルの２番目の要素を基準にソートします。
`sort_by()`は安定で最悪計算量が`O(n log n)`です。
ラムダ式みたいに`|x, y| y.1.cmp(&x.1)`とベクトルの要素を比較して整列します。
xとyを交換すると昇順になり、`y.0`と元キーだった要素でも比較ができる。

## ハッシュマップから最小（最大）の数を取り出す

`min_by`と`max_by`で最小と最大の要素をとりだせます。

```rust
// 最小を取得
let min = hashmap.iter()
  .min_by(|a, b| a.1.cmp(&b.1))
  .unwrap();
// (5, 1)


// 最大を取得
let max = hashmap.iter()
  .max_by(|a, b| a.1.cmp(&b.1))
  .unwrap();
// (1, 4)
```

## ハッシュマップを使ったAtCoderの問題

> **問題文**
>
> 高橋君は，$N$ 個のボールを持っています． 最初，$i$ 番目のボールには，整数 $A_i$ が書かれています．
> 高橋君は，いくつかのボールに書かれている整数を書き換えて，$N$ 個のボールに書かれている整数が $K$ 種類以下になるようにしたいです．
> 高橋君は，少なくとも何個のボールの整数を書き換える必要があるでしょうか？
>
> [ABC081 - C Not so Diverse](https://atcoder.jp/contests/abc081/tasks)

入出力や制約はAtCoderのページを見てください。

### 回答

クリックすると開きます。

<details><summary>回答と考え</summary>

この問題はハッシュマップでユニークな要素をそれぞれカウントして、数が小さい順に $K - Unique(Ai)$ 種類分の個数を合計した数が答えになります。

```rust
use std::collections::HashMap;
use std::collections::HashSet;

fn main() {
    proconio::input! {
        n: i32,
        k: i32,
        a: [i32; n]
    }
    // ユニークな数
    let uniq: HashSet<i32> = a.clone().into_iter().collect();
    let len = uniq.len() as i32 - k;
    if len <= 0 {
        println!("0");
        return;
    }
    // 要素ごとのカウント
    let mut map = HashMap::new();
    for x in a {
        let counter = map.entry(x).or_insert(0);
        *counter += 1;
    }
    // カウント順にソート
    let mut v: Vec<_> = map.into_iter().collect();
    v.sort_by(|x, y| x.1.cmp(&y.1));
    v.reverse();
    // println!("{:?}", v);
    let mut answer = 0;

    // 数が小さいものからk以下まで足し算
    for _ in 0..len {
        answer += v.pop().unwrap().1;
    }
    println!("{}", answer);
}
```

ユニークなボールの数は`HashSet`でわかる。

</details>


【Rust】HashMapで配列の同じ要素をカウントして多い順に並べる


Rustの数値型のベクトルをスペースやカンマなどの区切り文字を挟んだ文字列に変換(join)する書き方です。
Rustで競技プログラミングを始めたので必要としました。

`vec![1, 2, 3]`を`1 2 3`と出力させます。
イメージはPythonの`list.join(" ")`。

[playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=09f79ca9485db69ad1b98a822ab4e5da)でコードを実行確認できます。

## Contents

## 構文

```rust
// to_string
Vec<T>.iter().map(|x| x.to_string()).collect().join(" ")

// format!
Vec<T>.iter().map(|x| format!("{}", x)).collect().join(",")
```

この構文でベクトルを区切り文字で結合した文字列へ変換できる。
`format!("{}", x)`は応用が利くため便利。

以下で例と解説をする。

### 整数型

整数型のベクトルの例です。

```rust:rust
// 整数型
let src: Vec<i32> = vec![-3, -2, -1, 0, 1, 2, 3];

// 要素を整数型から文字列型変換
let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
// 文字列型vectorを区切り文字で結合
println!("{}", dst.join(" "));
```

```txt:出力
-3 -2 -1 0 1 2 3
```

要素が文字列の`Vec<String>`では区切り文字を指定して結合する`.join(" ")`が利用できます。
そのため、`Vec<i32>`を`.map()`で要素ごとに文字列へ変換して`Vec<String>`にしています。
区切り文字は`.join(",")`などと変更できます。

- `iter().map(|x| x.to_string())`は要素ごとに文字列へ変換する処理です。Rust版のラムダ式ですかね。
  - [std::iter](https://doc.rust-lang.org/std/iter/)
  - [std::iter::Map](https://doc.rust-lang.org/std/iter/struct.Map.html)
- `.collect()`は`Map`を`Vec<T>`に直すことができる。
  - [std::iter.collect](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect)
  - `std::iter::Map`は`std::iter`を継承しているっぽい。

### 浮動小数点型

浮動小数点型も同じです。

```rust:rust
// 浮動小数点型
let src: Vec<f32> = vec![-3.3, -2.2, -1.1, 0.0, 1.1, 2.2, 3.3];

let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
println!("{}", dst.join(" "));
```

```txt:出力
-3.3 -2.2 -1.1 0 1.1 2.2 3.3
```

`.0`は省略されるようです。

### 論理値型

浮動小数点型は`true`, `false`を出力できます。

```rust
    // 論理値型
    let src: Vec<bool> = vec![true, false];

    let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
    println!("{}", dst.join(" "));
```

```txt:出力
true false
```

## format

`format!`で要素を文字列にするときのカスタマイズが容易になります。

- [std::fmt](https://doc.rust-lang.org/std/fmt/)に例がたくさんあります。

### 0埋め, パディング

[std::fmt#sign0](https://doc.rust-lang.org/std/fmt/#sign0)

```rust
// 浮動小数点型 0パディング
let src: Vec<f32> = vec![-3.3, -2.2, -1.1, 0.0, 1.1, 2.2, 3.3];

let dst: Vec<String> = src.iter().map(|x| format!("{:05}", x)).collect();
println!("{}", dst.join(" "));
```

```txt:出力
-03.3 -02.2 -01.1 00000 001.1 002.2 003.3
```

`format!("{:05}", x)`が5桁の0埋めです。

その他のサイン。

```rust
assert_eq!(format!("Hello {:+}!", 5), "Hello +5!");
assert_eq!(format!("{:#x}!", 27), "0x1b!");
assert_eq!(format!("Hello {:05}!", 5),  "Hello 00005!");
assert_eq!(format!("Hello {:05}!", -5), "Hello -0005!");
assert_eq!(format!("{:#010x}!", 27), "0x0000001b!");
```

### fillalignment

[std::fmt#fillalignment](https://doc.rust-lang.org/std/fmt/#fillalignment)

```rust
assert_eq!(format!("Hello {:<5}!", "x"),  "Hello x    !");
assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");
assert_eq!(format!("Hello {:^5}!", "x"),  "Hello   x  !");
assert_eq!(format!("Hello {:>5}!", "x"),  "Hello     x!");
```

## 文字列型

文字列型の場合は既に要素が文字列であるため、変換が不要です。

```rust
let months = vec!["January", "February", "March", "April", "May", "June", "July",
          "August", "September", "October", "November", "December"];
println!("{}", months.join(", "));
```

```txt:出力
January, February, March, April, May, June, July, August, September, October, November, December
```

## タプルの場合

Rustのタプルは異なる型を納められます。
`map()`はジェネリックだったのと、整数型と浮動小数点型は`to_string()`を持つため混合していても良いかと考えてましたが、エラーが出ました。

```rust
let src = (500, 6.4, 1);
let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();

println!("{}", dst.join(" "));
```

```txt:出力
error[E0599]: no method named `iter` found for tuple `({integer}, {float}, {integer})` in the current scope
  --> src/main.rs:41:32
   |
41 |     let dst: Vec<String> = src.iter().map(|x| x.to_string()).collect();
   |                                ^^^^ method not found in `({integer}, {float}, {integer})`

error: aborting due to previous error
```

型を混合したものは`iter`で扱えないようです。

## おわり

- [playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=09f79ca9485db69ad1b98a822ab4e5da)


【Rust】エラーが出たときの RUST_BACKTRACE=1 を設定する

Rustのnumクレートの実行サンプル

【Rust】num-integerのdiv_mod_floor()とdiv_rem()の違い

【Rust】並列処理でマンデルブロ集合の画像を作るコード

【Rust】HashMapで配列の同じ要素をカウントして多い順に並べる

【Rust】数値型のベクトルをスペース区切りの文字列に変換(join)する