Rust on kenji.blog

Cara Menemukan Bilangan Prima Hingga 1000 Menggunakan Saringan Eratosthenes

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

Apa itu Saringan Eratosthenes

Saringan Eratosthenes adalah algoritma untuk menemukan semua bilangan prima hingga batas tertentu. Algoritmanya sederhana dan dapat diimplementasikan dengan langkah-langkah berikut:

Buat array boolean dengan N elemen dan inisialisasi semua elemen menjadi true.
Atur elemen ke-0 dan ke-1 dari array menjadi false (karena 0 dan 1 bukan bilangan prima).
Jika elemen ke-2 dari array adalah true, maka cetak 2 sebagai bilangan prima.
Atur semua elemen kelipatan 2 mulai dari $2^2$ menjadi false ※
Jika elemen ke-3 dari array adalah true, maka cetak 3 sebagai bilangan prima.
Atur semua elemen kelipatan 3 mulai dari $3^2$ menjadi false.
Ulangi proses yang sama untuk elemen ke-4, ke-5, …, ke-N.

※ Alasan kami menargetkan elemen dari kuadrat ke atas untuk diatur menjadi false adalah karena elemen yang lebih kecil dari kuadrat tersebut sudah diproses (pencacahan telah selesai).

Implementasi dalam 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;
 }
 }
 }
}

Versi yang Sedikit Lebih Cepat

Kami akan menerapkan versi yang sedikit lebih cepat dengan mempertimbangkan hal-hal berikut:

Alih-alih menginisialisasi array dengan true, inisialisasi dengan false (ini lebih cepat).
Karena kelipatan 2 bukan bilangan prima, kami mengabaikan proses mengubah kelipatan 2 menjadi false.
Tidak perlu melakukan perulangan hingga n; jika Anda menemukan bilangan prima hingga akar kuadrat dari n, Anda dapat menemukan bilangan prima hingga 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);
 }
}

Referensi

Saringan Eratosthenes

Cara Menampilkan Bahasa Jepang di egui

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

Mendapatkan Contoh egui

Anda dapat menjalankan contoh egui dengan perintah berikut.

1
2
3


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

Memuat Font yang Mendukung Bahasa Jepang

Untuk menampilkan bahasa Jepang, Anda perlu memuat font yang mendukungnya.

Di src/app.rs, tambahkan baris berikut di dalam metode pub fn new.

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


// Memuat font yang mendukung bahasa Jepang
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);

Sekarang Anda Dapat Menampilkan Bahasa Jepang.

Cara memperbarui rustc

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

Cara memperbarui rustc

Cukup jalankan satu baris berikut dengan perintah.

1

rustup update

Referensi keluaran

 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

Mencoba egui

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

Apa itu egui

Ini adalah pustaka GUI yang dapat digunakan dengan rust.

Mencoba egui

Anda dapat menjalankan contoh egui dengan perintah berikut.

1
2
3


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

Setelah itu, Anda dapat mencoba berbagai hal sambil bermain-main dengan kode contohnya.

Referensi

Repositori resmi di github

Fitur Rust

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

Fitur Rust

Bahasa pemrograman open source yang relatif baru yang dikembangkan oleh Mozilla
Bahasa yang cepat tanpa garbage collection, dikhususkan untuk pemrograman sistem
Memiliki mekanisme kepemilikan dan peminjaman yang unik sebagai spesifikasi bahasa, dan menjamin keamanan memori
Beroperasi secara lintas platform
Memiliki manajer paket yang sangat baik yang disebut Cargo sebagai standar

Menampilkan jendela sederhana di Rust

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

Menampilkan jendela sederhana di 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"]

Kode sumbernya ada di bawah

 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
}

Referensi

Pemrograman Windows di Rust - bagian CreateWindow

Menulis Pengujian di Rust

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

Untuk menulis pengujian di Rust, buat sebuah fungsi dan tambahkan atribut #[test] satu baris di atas definisi fungsi pengujian tersebut.

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

Kode pengujian dapat dijalankan dengan cargo test. Jika pengujian berhasil, ok akan dikeluarkan. Jika gagal, FAILED akan dikeluarkan.

Jika berhasil

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

Jika gagal

 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'

Menampilkan MessageBox di Rust

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

Anda dapat menampilkan MessageBox di Rust dengan mengikuti langkah-langkah di bawah ini.

Instal Rust. Lihat Cara memulai Rust
Jalankan cargo new --bin MessageBox di command prompt.
Pindah ke direktori MessageBox.
Buka Cargo.toml dan modifikasi seperti di bawah ini.

 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"

Buka src\main.rs dan modifikasi seperti di bawah ini.

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

Jalankan cargo run di command prompt.
Untuk melakukan build rilis, jalankan cargo build --release.

Referensi

Hello World MesssageBox example in Rust

Menghitung Bilangan Prima di Rust

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

Saya menulis program untuk membuat daftar bilangan prima di 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);
 }
}

Cara Memulai dengan Rust

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

Pengantar

Rust adalah bahasa pemrograman yang relatif baru yang memungkinkan Anda menulis modul yang cepat dan efisien dalam penggunaan memori dengan sintaksis modern. Bahasa ini mendukung multi-platform dan juga digunakan di dunia WebAssembly dan sistem tertanam (embedded). Selain itu, bahasa ini digunakan oleh perusahaan terkenal seperti Firefox, DropBox, dan Cloudflare.

Rust juga menarik perhatian sebagai alternatif dari C++.

Cara Menginstal

Instal Rust

Instruksi instalasi untuk setiap platform tersedia di situs di atas.

Program Pertama Anda

Simpan program berikut sebagai main.rs.

1
2
3


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

Jika Anda menjalankan rustc main.rs dari command prompt atau terminal, itu akan dikompilasi, dan menjalankan ./main (untuk Windows main.exe) akan menghasilkan Hello, world!.

Dokumentasi (Bahasa Jepang)

The Rust Programming Language Versi Jepang

Semua penjelasan yang diperlukan untuk mempelajari Rust telah dirangkum di tautan di atas (versi terjemahan bahasa Jepang). Itu sangat lengkap sehingga Anda tidak perlu membeli buku teks tentang Rust.

Jika Anda Ingin Mencobanya di Web

Jika Anda ingin mencoba menjalankannya di web tanpa menginstal kompiler, Anda dapat menggunakan The Rust Playground. Masukkan kode Anda dan tekan tombol “Jalankan”, lalu kode akan dikompilasi dan dijalankan di web.