Rust on kenji.blog

Como listar números primos menores que 1000 usando o Crivo de Eratóstenes

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

O que é o Crivo de Eratóstenes?

O Crivo de Eratóstenes é um algoritmo para encontrar todos os números primos até um determinado limite. O algoritmo é simples e pode ser implementado através das seguintes etapas:

Crie um array booleano com N elementos e inicialize todos os elementos como verdadeiros (true).
Defina os elementos nas posições 0 e 1 do array como falsos (pois 0 e 1 não são números primos).
Se o 2º elemento do array for verdadeiro, imprima 2 como número primo.
Defina todos os múltiplos de 2 a partir de $2^2$ como falsos (*).
Se o 3º elemento do array for verdadeiro, imprima 3 como número primo.
Defina todos os múltiplos de 3 a partir de $3^2$ como falsos.
Repita o mesmo processo para o 4º, 5º, …, e N-ésimo elementos.

O motivo de começar a definir como falsos os múltiplos a partir do quadrado (ex: $2^2$) é que os números menores que o quadrado já foram processados (já foram marcados ou listados).

Implementação em 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;
 }
 }
 }
}

Versão levemente otimizada

Podemos otimizar um pouco a implementação considerando os seguintes pontos:

Inicializar o array com falso (false) em vez de verdadeiro (true) (isso é mais rápido).
Uma vez que múltiplos de 2 não são números primos, pule o processo de definir múltiplos de 2 como falso.
Não é necessário iterar até n; listar os números primos até a raiz quadrada de n é suficiente para encontrar todos os primos menores ou iguais a 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);
 }
}

Referência

Crivo de Eratóstenes (Wikipedia)

Como exibir japonês no egui

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

Obtenha a amostra do egui

Você pode executar a amostra do egui com o seguinte comando.

1
2
3


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

Carregue uma fonte compatível com japonês

Para exibir texto em japonês, você deve carregar uma fonte que suporte o idioma japonês.

No arquivo src/app.rs, adicione as seguintes linhas dentro do método pub fn new.

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


// Carregar a fonte compatível com japonês
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);

Agora você pode exibir japonês.

Como atualizar o rustc

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

Como atualizar o rustc

Basta executar a seguinte linha de comando.

1

rustup update

Referência de saída

 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

Características do Rust

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

Características do Rust

Uma linguagem de programação de código aberto relativamente nova desenvolvida pela Mozilla
Linguagem rápida, sem coleta de lixo (garbage collection), especializada em programação de sistemas
Garante a segurança de memória com mecanismos únicos de propriedade (ownership) e empréstimo (borrowing) como especificações da linguagem
Funciona em multiplataformas
Possui o excelente gerenciador de pacotes Cargo como padrão

Exibir uma janela simples em Rust

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

Exibir uma janela simples em 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"]

O código-fonte está abaixo

 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
}

Referências

Programação Windows em Rust - CreateWindow

Escrevendo testes em Rust

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

Para escrever um teste em Rust, adicione o atributo #[test] uma linha acima da definição da função de teste.

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

O código de teste pode ser executado com cargo test. Quando o teste for bem-sucedido, ele exibirá ok. Se falhar, exibirá FAILED.

Caso de sucesso

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

Caso de falha

 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'

Exibir um MessageBox em Rust

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

Você pode exibir um MessageBox em Rust seguindo os passos abaixo.

Instale o Rust. Consulte Como começar com Rust
Execute cargo new --bin MessageBox no prompt de comando.
Vá para o diretório MessageBox.
Abra Cargo.toml e modifique-o conforme abaixo.

 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"

Abra src\main.rs e modifique-o conforme abaixo.

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

Execute cargo run no prompt de comando.
Se você deseja fazer uma compilação de release, execute cargo build --release.

Referência

Hello World MesssageBox example in Rust

Enumerando Números Primos em Rust

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

Escrevi um programa para enumerar números primos em 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);
 }
}

Como começar com Rust

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

Introdução

Rust é uma linguagem de programação relativamente nova que permite escrever módulos rápidos e eficientes em memória com uma sintaxe moderna. É compatível com várias plataformas e também é usada no mundo do WebAssembly e em sistemas embarcados. De forma notável, foi adotada pelo Firefox, DropBox e Cloudflare.

Também está atraindo atenção como uma alternativa ao C++.

Como instalar

Instalar o Rust

O site acima fornece instruções de instalação para cada plataforma.

Primeiro programa

Salve o seguinte programa como main.rs.

1
2
3


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

Ao executar rustc main.rs no prompt de comando ou terminal, ele será compilado. Executar ./main (ou main.exe no Windows) exibirá Hello, world!.

Documentação em Japonês

The Rust Programming Language Edição Japonesa

As explicações necessárias para aprender Rust estão compiladas no link acima (versão traduzida para o japonês). É tão abrangente que você não precisa comprar um livro sobre Rust.

Se você quiser experimentar na Web

Se você quiser experimentá-lo na Web sem instalar o compilador, pode usar The Rust Playground. Após inserir o código e clicar no botão “Run”, ele será compilado e executado na Web.