Rust on kenji.blog

Wie man Primzahlen unter 1000 mit dem Sieb des Eratosthenes auflistet

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

Was ist das Sieb des Eratosthenes?

Das Sieb des Eratosthenes ist ein Algorithmus, mit dem alle Primzahlen bis zu einem bestimmten Grenzwert gefunden werden können. Der Algorithmus ist einfach und kann durch die folgenden Schritte implementiert werden:

Erstellen Sie ein boolesches Array mit N Elementen und initialisieren Sie alle Elemente auf wahr (true).
Setzen Sie das nullte und das erste Element des Arrays auf falsch (false) (da 0 und 1 keine Primzahlen sind).
Wenn das 2. Element des Arrays wahr ist, geben Sie 2 als Primzahl aus.
Setzen Sie alle Vielfachen von 2 ab $2^2$ auf falsch (*).
Wenn das 3. Element des Arrays wahr ist, geben Sie 3 als Primzahl aus.
Setzen Sie alle Vielfachen von 3 ab $3^2$ auf falsch.
Wiederholen Sie den gleichen Vorgang für das 4., 5., …, und N-te Element.

Der Grund, warum die Elemente ab dem Quadrat des Wertes auf falsch gesetzt werden, liegt daran, dass Zahlen, die kleiner als das Quadrat sind, bereits in vorherigen Schritten verarbeitet wurden.

Implementierung in 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;
 }
 }
 }
}

Leicht optimierte Version

Wir können die Implementierung unter Berücksichtigung der folgenden Punkte leicht optimieren:

Initialisieren Sie das Array mit falsch (false) statt mit wahr (true) (das ist schneller).
Da Vielfache von 2 keine Primzahlen sind, überspringen Sie den Schritt, bei dem die Vielfachen von 2 auf falsch gesetzt werden.
Es ist nicht notwendig, bis n zu iterieren; es reicht aus, die Primzahlen bis zur Quadratwurzel von n zu berechnen, um alle Primzahlen zu finden, die kleiner oder gleich n sind.

 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);
 }
}

Referenz

Sieb des Eratosthenes (Wikipedia)

Wie man Japanisch in egui anzeigt

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

Holen Sie sich das egui Beispiel

Sie können das egui-Beispiel mit dem folgenden Befehl ausführen.

1
2
3


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

Laden Sie eine japanisch-kompatible Schriftart

Um Japanisch anzuzeigen, müssen Sie eine Schriftart laden, die die japanische Sprache unterstützt.

Fügen Sie in src/app.rs die folgenden Zeilen in die Methode pub fn new ein.

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


// Laden Sie eine japanisch-kompatible Schriftart
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);

Jetzt können Sie Japanisch anzeigen.

Wie man rustc aktualisiert

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

Wie man rustc aktualisiert

Führen Sie einfach die folgende Zeile in der Befehlszeile aus.

1

rustup update

Ausgabereferenz

 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

Eigenschaften von Rust

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

Eigenschaften von Rust

Eine relativ neue Open-Source-Programmiersprache, die von Mozilla entwickelt wird
Eine schnelle Sprache ohne Garbage Collection, die auf Systemprogrammierung spezialisiert ist
Garantiert Speichersicherheit durch einzigartige Mechanismen für Besitz (ownership) und Ausleihen (borrowing) als Teil der Sprachspezifikation
Funktioniert plattformübergreifend
Besitzt standardmäßig den hervorragenden Paketmanager Cargo

Ein einfaches Fenster in Rust anzeigen

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

Ein einfaches Fenster in Rust anzeigen

 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"]

Der Quellcode ist unten

 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
}

Referenzen

Windows-Programmierung in Rust - CreateWindow

Tests in Rust schreiben

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

Um Tests in Rust zu schreiben, erstellen Sie eine Funktion, indem Sie das Attribut #[test] eine Zeile über der Definition der Testfunktion hinzufügen.

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);
}

Der Testcode kann mit cargo test ausgeführt werden. Wenn der Test erfolgreich ist, wird ok ausgegeben. Wenn er fehlschlägt, wird FAILED ausgegeben.

Im Erfolgsfall

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

Im Fehlerfall

 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'

Anzeigen einer MessageBox in Rust

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

Sie können eine MessageBox in Rust anzeigen, indem Sie die folgenden Schritte ausführen.

Installieren Sie Rust. Siehe Erste Schritte mit Rust
Führen Sie cargo new --bin MessageBox in der Eingabeaufforderung aus.
Wechseln Sie in das Verzeichnis MessageBox.
Öffnen Sie Cargo.toml und ändern Sie es wie folgt.

 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"

Öffnen Sie src\main.rs und ändern Sie es wie folgt.

 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
 );
 }
}

Führen Sie cargo run in der Eingabeaufforderung aus.
Um einen Release-Build zu erstellen, führen Sie cargo build --release aus.

Referenz

Hello World MesssageBox example in Rust

Aufzählung von Primzahlen in Rust

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

Ich habe ein Programm geschrieben, um Primzahlen in Rust aufzuzählen.

 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);
 }
}

Wie man mit Rust anfängt

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

Einführung

Rust ist eine relativ neue Programmiersprache, mit der Sie schnelle und speichereffiziente Module mit moderner Syntax schreiben können. Es ist plattformübergreifend und wird auch in der Welt von WebAssembly und eingebetteten Systemen verwendet. Bekanntermaßen wird es von Firefox, DropBox und Cloudflare eingesetzt.

Es zieht auch als Alternative zu C++ Aufmerksamkeit auf sich.

Wie man installiert

Rust installieren

Die obige Website bietet Installationsanweisungen für jede Plattform.

Erstes Programm

Speichern Sie das folgende Programm als main.rs.

1
2
3


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

Wenn Sie rustc main.rs über die Eingabeaufforderung oder das Terminal ausführen, wird es kompiliert. Die Ausführung von ./main (oder main.exe unter Windows) gibt Hello, world! aus.

Japanische Dokumentation

The Rust Programming Language Japanische Ausgabe

Die Erklärungen, die zum Erlernen von Rust notwendig sind, sind unter dem obigen Link (japanisch übersetzte Version) zusammengestellt. Sie ist so umfassend, dass Sie kein Buch über Rust kaufen müssen.

Wenn Sie es im Web ausprobieren möchten

Wenn Sie es im Web ausprobieren möchten, ohne den Compiler zu installieren, können Sie The Rust Playground verwenden. Nach der Eingabe des Codes und dem Klicken auf die Schaltfläche “Run” wird er im Web kompiliert und ausgeführt.