Rust on kenji.blog

Comment lister les nombres premiers inférieurs à 1000 en utilisant le Crible d'Ératosthène

Sun, 09 Apr 2023 12:54:24 +0900

Qu’est-ce que le Crible d’Ératosthène ?

Le Crible d’Ératosthène est un algorithme utilisé pour trouver tous les nombres premiers jusqu’à une limite donnée. L’algorithme est simple et peut être implémenté via les étapes suivantes :

Créer un tableau booléen de N éléments et initialiser tous les éléments à vrai (true).
Définir les 0ème et 1er éléments du tableau sur faux (false) (car 0 et 1 ne sont pas premiers).
Si le 2ème élément du tableau est vrai, afficher 2 comme nombre premier.
Définir tous les multiples de 2 supérieurs ou égaux à $2^2$ sur faux (*).
Si le 3ème élément du tableau est vrai, afficher 3 comme nombre premier.
Définir tous les multiples de 3 supérieurs ou égaux à $3^2$ sur faux.
Répéter le même processus pour les 4ème, 5ème, …, et N-ième éléments.

La raison pour laquelle on commence à marquer comme faux à partir du carré du nombre est que les nombres inférieurs au carré ont déjà été traités lors des étapes précédentes.

Implémentation en Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Version légèrement optimisée

Nous pouvons optimiser légèrement l’implémentation en considérant les points suivants :

Initialiser le tableau à faux (false) au lieu de vrai (true) (cela est plus rapide).
Puisque les multiples de 2 ne sont pas des nombres premiers, ignorer l’étape visant à définir les multiples de 2 sur faux.
Il n’est pas nécessaire de boucler jusqu’à n ; trouver les nombres premiers jusqu’à la racine carrée de n suffit pour trouver tous les nombres premiers inférieurs ou égaux à n.

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


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

Référence

Crible d’Ératosthène (Wikipedia)

Comment afficher du japonais dans egui

Sat, 01 Apr 2023 03:17:52 +0900

Obtenir l’exemple egui

Vous pouvez exécuter l’exemple egui avec la commande suivante.

1
2
3


git clone https://github.com/emilk/eframe_template/ egui_test
cd egui_test
cargo run

Charger une police compatible avec le japonais

Pour afficher du japonais, vous devez charger une police qui le prend en charge.

Dans src/app.rs, ajoutez les lignes suivantes à l’intérieur de la méthode pub fn new.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Charger une police compatible avec le japonais
let mut fonts = egui::FontDefinitions::default();
fonts.font_data.insert(
 "Meiryo".to_owned(),
 egui::FontData::from_static(include_bytes!("C:/Windows/Fonts/Meiryo.ttc")),
);
fonts
 .families
 .entry(egui::FontFamily::Proportional)
 .or_default()
 .insert(0, "Meiryo".to_owned());
cc.egui_ctx.set_fonts(fonts);

Vous pouvez maintenant afficher du japonais.

Comment mettre à jour rustc

Sat, 18 Mar 2023 10:27:02 +0900

Comment mettre à jour rustc

Exécutez simplement la ligne suivante en ligne de commande.

1

rustup update

Référence de sortie

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
warning: Signature verification failed for 'https://static.rust-lang.org/dist/channel-rust-stable.toml'
info: latest update on 2023-03-09, rust version 1.68.0 (2c8cc3432 2023-03-06)
info: downloading component 'rust-src'
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-std'
info: downloading component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 37.5 MiB/s in 1s ETA: 0s
info: downloading component 'rustfmt'
info: removing previous version of component 'rust-src'
info: removing previous version of component 'cargo'
info: removing previous version of component 'clippy'
info: removing previous version of component 'rust-docs'
info: removing previous version of component 'rust-std'
info: removing previous version of component 'rustc'
info: removing previous version of component 'rustfmt'
info: installing component 'rust-src'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 19.4 MiB / 19.4 MiB (100 %) 2.4 MiB/s in 6s ETA: 0s
info: installing component 'rust-std'
 27.6 MiB / 27.6 MiB (100 %) 12.7 MiB/s in 2s ETA: 0s
info: installing component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 13.8 MiB/s in 4s ETA: 0s
info: installing component 'rustfmt'
info: checking for self-updates
info: downloading self-update

 stable-x86_64-pc-windows-msvc updated - rustc 1.68.0 (2c8cc3432 2023-03-06) (from rustc 1.64.0 (a55dd71d5 2022-09-19))

info: cleaning up downloads & tmp directories

Caractéristiques de Rust

Mon, 03 Oct 2022 22:47:20 +0900

Caractéristiques de Rust

Un langage de programmation open source relativement récent développé par Mozilla
Un langage rapide sans ramasse-miettes (garbage collection), spécialisé dans la programmation système
Garantit la sécurité de la mémoire grâce à des mécanismes uniques de propriété (ownership) et d’emprunt (borrowing) intégrés aux spécifications du langage
Fonctionne de manière multiplateforme
Intègre en standard l’excellent gestionnaire de paquets Cargo

Afficher une fenêtre simple en Rust

Sat, 01 Oct 2022 19:08:58 +0900

Afficher une fenêtre simple en Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "win"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies.winapi]
version = "0.3"
features = ["winuser"]

Le code source est ci-dessous

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![windows_subsystem = "windows"]
use winapi::{
 um::{
 winuser::{RegisterClassW, WNDCLASSW, CS_HREDRAW, CS_VREDRAW,
 LoadIconW, IDI_APPLICATION, LoadCursorW, IDC_ARROW,
 CreateWindowExW, ShowWindow, SW_NORMAL, UpdateWindow,
 GetMessageW, TranslateMessage, DispatchMessageW, MSG,
 WM_DESTROY, PostQuitMessage, DefWindowProcW, WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT},
 wingdi::{GetStockObject, WHITE_BRUSH},
 },
 shared::{
 windef::{HWND, HBRUSH},
 minwindef::{UINT, WPARAM, LPARAM, LRESULT},
 },
};
use std::ptr;
use std::mem;

fn main() {
 unsafe {
 let class_name = encode("my_window_class_name");
 if !register_wndclass(&class_name) {
 return;
 }
 let hwnd = create_window(&class_name);
 if hwnd.is_null() {
 return;
 }
 ShowWindow(hwnd, SW_NORMAL);
 UpdateWindow(hwnd);
 let mut msg = mem::uninitialized::<MSG>();
 loop {
 if GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
 return;
 }
 TranslateMessage(&mut msg);
 DispatchMessageW(&mut msg);
 }
 }
}

fn encode(source: &str) -> Vec<u16> {
 source.encode_utf16().chain(Some(0)).collect()
}

unsafe fn register_wndclass(class_name: &[u16]) -> bool {
 let mut winc = mem::zeroed::<WNDCLASSW>();
 winc.style = CS_HREDRAW | CS_VREDRAW;
 winc.lpfnWndProc = Some(win_proc);
 winc.hIcon = LoadIconW(ptr::null_mut(), IDI_APPLICATION);
 winc.hCursor = LoadCursorW(ptr::null_mut(), IDC_ARROW);
 winc.hbrBackground = GetStockObject(WHITE_BRUSH as i32) as HBRUSH;
 winc.lpszClassName = class_name.as_ptr();
 RegisterClassW(&winc) > 0
}

unsafe fn create_window(class_name: &[u16]) -> HWND {
 CreateWindowExW(
 0,
 class_name.as_ptr(),
 encode("Hello, World!").as_ptr(),
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 )
}

unsafe extern "system" fn win_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
 match msg {
 WM_DESTROY => PostQuitMessage(0),
 _ => return DefWindowProcW(hwnd, msg, w_param, l_param),
 };
 0
}

Références

Programmation Windows en Rust - CreateWindow

Écrire des tests en Rust

Sat, 01 Oct 2022 02:00:59 +0900

Pour écrire des tests en Rust, créez la fonction en ajoutant l’attribut #[test] une ligne au-dessus de la définition de la fonction de test.

1
2
3
4
5
6
7
8


fn plus(a:i32,b:i32)->i32 {
 a+b
}

#[test]
fn plus_test() {
 assert_eq!(plus(1, 1), 2);
}

Le code de test peut être exécuté avec cargo test. Si le test réussit, il affichera ok. S’il échoue, il affichera FAILED.

En cas de succès

1
2
3
4
5
6
7
8
9


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.35s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

En cas d’échec

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.33s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... FAILED

failures:

---- plus_test stdout ----
thread 'plus_test' panicked at 'assertion failed: `(left == right)`
 left: `2`,
 right: `3`', src\main.rs:7:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
 plus_test

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--bin test1'

Afficher une MessageBox en Rust

Fri, 30 Sep 2022 23:54:31 +0900

Vous pouvez afficher une MessageBox en Rust en suivant les étapes ci-dessous.

Installez Rust. Consultez Comment débuter avec Rust
Exécutez cargo new --bin MessageBox dans l’invite de commande.
Accédez au répertoire MessageBox.
Ouvrez Cargo.toml et modifiez-le comme suit.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
winapi = "0.2.7"
user32-sys = "0.2.0"

Ouvrez src\main.rs et modifiez-le comme suit.

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


extern crate user32;
extern crate winapi;

use std::ffi::CString;
use user32::MessageBoxA;
use winapi::winuser::{MB_OK, MB_ICONINFORMATION};

fn main() {
 let lp_text = CString::new("Hello, world!").unwrap();
 let lp_caption = CString::new("MessageBox Example").unwrap();

 unsafe {
 MessageBoxA(
 std::ptr::null_mut(),
 lp_text.as_ptr(),
 lp_caption.as_ptr(),
 MB_OK | MB_ICONINFORMATION
 );
 }
}

Exécutez cargo run dans l’invite de commande.
Si vous souhaitez effectuer une version de release, exécutez cargo build --release.

Référence

Hello World MesssageBox example in Rust

Énumération des nombres premiers en Rust

Fri, 09 Sep 2022 07:08:49 +0900

J’ai écrit un programme pour énumérer les nombres premiers en Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}

Comment débuter avec Rust

Tue, 06 Sep 2022 00:12:36 +0900

Introduction

Rust est un langage de programmation relativement nouveau qui vous permet d’écrire des modules rapides et économes en mémoire avec une syntaxe moderne. Il prend en charge le multiplateforme et est également utilisé dans le monde du WebAssembly et des systèmes embarqués. Il a notamment été adopté par Firefox, DropBox et Cloudflare.

Il attire également l’attention en tant qu’alternative au C++.

Comment installer

Installer Rust

Le site ci-dessus fournit des instructions d’installation pour chaque plateforme.

Premier programme

Enregistrez le programme suivant sous le nom main.rs.

1
2
3


fn main() {
 println!("Hello, world!");
}

En exécutant rustc main.rs depuis l’invite de commande ou le terminal, il sera compilé. L’exécution de ./main (main.exe sous Windows) affichera Hello, world!.

Documentation en japonais

The Rust Programming Language Édition japonaise

Les explications nécessaires pour apprendre Rust sont compilées dans le lien ci-dessus (version traduite en japonais). Elle est si complète que vous n’avez pas besoin d’acheter un livre sur Rust.

Si vous voulez l’essayer sur le Web

Si vous voulez l’essayer sur le Web sans installer le compilateur, vous pouvez utiliser The Rust Playground. Après avoir entré le code et cliqué sur le bouton “Run”, il sera compilé et exécuté sur le Web.