Rust on kenji.blog

इरेटोस्थनीज की छलनी का उपयोग करके 1000 से कम अभाज्य संख्याओं को सूचीबद्ध करने की विधि

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

इरेटोस्थनीज की छलनी क्या है?

इरेटोस्थनीज की छलनी एक एल्गोरिथ्म है जो किसी दी गई संख्या से छोटे सभी अभाज्य संख्याओं (prime numbers) को सूचीबद्ध करता है। यह एल्गोरिथ्म सरल है और इसे निम्नलिखित चरणों में लागू किया जा सकता है:

N तत्वों वाली एक बूलियन ऐरे बनाएँ और सभी तत्वों को true से इनिशियलाइज़ करें।
ऐरे के 0वें और 1ले तत्व को false सेट करें (क्योंकि 0 और 1 अभाज्य नहीं हैं)।
यदि ऐरे का दूसरा तत्व true है, तो 2 को अभाज्य के रूप में आउटपुट करें।
ऐरे में $2^2$ और उससे अधिक 2 के गुणजों (multiples) वाले तत्वों को false सेट करें ※
यदि ऐरे का तीसरा तत्व true है, तो 3 को अभाज्य के रूप में आउटपुट करें।
ऐरे में $3^2$ और उससे अधिक 3 के गुणजों वाले तत्वों को false सेट करें।
चौथे, 5वें, …, Nवें तत्वों के लिए यही प्रक्रिया दोहराएँ।

※ हम वर्गों (squares) से ऊपर के तत्वों को false सेट करते हैं क्योंकि वर्ग से छोटी संख्याओं पर पहले ही प्रक्रिया हो चुकी होती है।

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

थोड़ा अनुकूलित संस्करण

निम्नलिखित बिंदुओं को ध्यान में रखते हुए, हम थोड़ा तेज़ कार्यान्वयन बना सकते हैं:

ऐरे को true के बजाय false से इनिशियलाइज़ करें (यह तेज़ है)।
चूँकि 2 के गुणज अभाज्य नहीं होते हैं, इसलिए 2 के गुणजों को false सेट करने की प्रक्रिया को छोड़ दें।
n तक लूप करने की आवश्यकता नहीं है; n के वर्गमूल तक अभाज्य संख्याओं को सूचीबद्ध करना, 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);
 }
}

संदर्भ

इरेटोस्थनीज की छलनी

egui में जापानी कैसे प्रदर्शित करें

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

egui का नमूना प्राप्त करें

आप निम्न कमांड के साथ egui नमूना चला सकते हैं।

1
2
3


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

जापानी-समर्थित फ़ॉन्ट लोड करें

जापानी प्रदर्शित करने के लिए, आपको एक ऐसा फ़ॉन्ट लोड करना होगा जो जापानी भाषा का समर्थन करता हो।

src/app.rs में, pub fn new विधि के अंदर निम्नलिखित पंक्तियाँ जोड़ें।

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


// जापानी-समर्थित फ़ॉन्ट लोड करें
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);

अब आप जापानी प्रदर्शित कर सकते हैं।

rustc को अपडेट करने का तरीका

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

rustc को अपडेट करने का तरीका

बस कमांड में निम्नलिखित एक पंक्ति चलाएं।

1

rustup update

आउटपुट संदर्भ

 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

Rust की विशेषताएं

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

Rust की विशेषताएं

मोज़िला (Mozilla) द्वारा विकसित एक अपेक्षाकृत नई ओपन-सोर्स प्रोग्रामिंग भाषा
बिना गार्बेज कलेक्शन वाली एक तेज़ भाषा जो सिस्टम प्रोग्रामिंग के लिए विशेष रूप से डिज़ाइन की गई है
इसमें स्वामित्व (ownership) और उधार (borrowing) के अद्वितीय तंत्र भाषा विनिर्देश के रूप में हैं, जो मेमोरी सुरक्षा की गारंटी देते हैं
यह क्रॉस-प्लेटफॉर्म पर काम करती है
इसमें मानक के रूप में Cargo नामक एक बेहतरीन पैकेज मैनेजर है

Rust में एक साधारण विंडो प्रदर्शित करना

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

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

स्रोत कोड नीचे है

 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
}

संदर्भ

Rust में विंडोज प्रोग्रामिंग - CreateWindow

Rust में टेस्ट लिखना

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

Rust में टेस्ट लिखने के लिए, टेस्ट फ़ंक्शन की परिभाषा के ठीक ऊपर #[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);
}

टेस्ट कोड को cargo test से चलाया जा सकता है। जब टेस्ट सफल होता है, तो यह ok आउटपुट देता है। विफल होने पर, यह FAILED आउटपुट देता है।

सफल होने पर

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

विफल होने पर

 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'

Rust में MessageBox प्रदर्शित करें

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

आप नीचे दिए गए चरणों का पालन करके Rust में MessageBox प्रदर्शित कर सकते हैं।

Rust स्थापित करें। Rust के साथ शुरुआत कैसे करें देखें
कमांड प्रॉम्प्ट में cargo new --bin MessageBox चलाएँ।
MessageBox निर्देशिका में जाएँ।
Cargo.toml खोलें और नीचे दिए गए अनुसार संशोधित करें।

 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"

src\main.rs खोलें और नीचे दिए गए अनुसार संशोधित करें।

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

कमांड प्रॉम्प्ट में cargo run चलाएँ।
रिलीज़ बिल्ड बनाने के लिए cargo build --release चलाएँ।

संदर्भ

Hello World MesssageBox example in Rust

Rust में अभाज्य संख्याओं की गणना

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

मैंने 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);
 }
}

Rust के साथ कैसे शुरू करें

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

परिचय

Rust एक अपेक्षाकृत नई प्रोग्रामिंग भाषा है जो आपको आधुनिक सिंटैक्स के साथ तेज़ और मेमोरी-कुशल मॉड्यूल लिखने की अनुमति देती है। यह मल्टी-प्लेटफॉर्म का समर्थन करती है और इसका उपयोग WebAssembly और एम्बेडेड सिस्टम की दुनिया में भी किया जाता है। प्रसिद्ध रूप से, इसे Firefox, DropBox और Cloudflare द्वारा अपनाया गया है।

यह C++ के विकल्प के रूप में भी ध्यान आकर्षित कर रहा है।

कैसे इंस्टॉल करें

Rust इंस्टॉल करें

उपरोक्त वेबसाइट प्रत्येक प्लेटफॉर्म के लिए इंस्टॉलेशन निर्देश प्रदान करती है।

पहला प्रोग्राम

निम्नलिखित प्रोग्राम को main.rs के रूप में सहेजें।

1
2
3


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

कमांड प्रॉम्प्ट या टर्मिनल से rustc main.rs चलाने पर, यह संकलित हो जाएगा। ./main (Windows पर main.exe) चलाने से Hello, world! आउटपुट होगा।

जापानी दस्तावेज़ीकरण

The Rust Programming Language जापानी संस्करण

Rust सीखने के लिए आवश्यक स्पष्टीकरण उपरोक्त लिंक (जापानी अनुवाद संस्करण) में संकलित हैं। यह इतना व्यापक है कि आपको Rust के बारे में कोई किताब खरीदने की आवश्यकता नहीं है।

यदि आप इसे वेब पर आजमाना चाहते हैं

यदि आप कंपाइलर स्थापित किए बिना इसे वेब पर आजमाना चाहते हैं, तो आप The Rust Playground का उपयोग कर सकते हैं। कोड दर्ज करने और “Run” बटन दबाने के बाद, यह वेब पर संकलित और निष्पादित किया जाएगा।