В языке Rust можно побитово проверить, является ли число положительным, используя знаковый бит. У целых чисел со знаком (например, i32, i64 и т.д.) старший бит (называемый знаковым битом) указывает на знак числа: если он равен 0, число положительное, если 1 — отрицательное.

Пример проверки для 32-битного целого числа (i32):

fn is_positive(n: i32) -> bool {
// Проверяем, равен ли знаковый бит 0
(n & (1 << 31)) == 0
}

fn main() {
let num = 42;
if is_positive(num) {
println!(«Число {} положительное.», num);
} else {
println!(«Число {} отрицательное.», num);
}
}

Объяснение:

• 1 << 31 создаёт маску, где установлен только 31-й бит (знаковый бит для i32).
• n & (1 << 31) выполняет побитовую операцию И, чтобы извлечь значение знакового бита.
• Если результат равен 0, число положительное, иначе — отрицательное.

Примечание:

• Для других типов (например, i64) нужно изменить сдвиг: 1 << 63.
• Этот метод работает только для целых чисел со знаком. Для беззнаковых чисел (u32, u64 и т.д.) все числа по определению неотрицательные, и такая проверка не имеет смысла.

Если вам нужно просто проверить знак числа, можно использовать встроенные методы, например:

fn main() {
let num = 42;
if num.is_positive() {
println!(«Число {} положительное.», num);
} else {
println!(«Число {} отрицательное.», num);
}
}

Метод is_positive() доступен для всех целых чисел со знаком в Rust.

---

В языке Rust (и в программировании в целом) числовые маски — это специальные значения, которые используются для выполнения побитовых операций над числами. Маски позволяют извлекать, устанавливать, сбрасывать или инвертировать определённые биты в числе. Они часто применяются для работы с флагами, битовыми полями или для оптимизации определённых операций.

Основные побитовые операции

В Rust поддерживаются следующие побитовые операции, которые часто используются с масками:

1. И (AND, &): Возвращает 1 только если оба соответствующих бита равны 1.
2. ИЛИ (OR, |): Возвращает 1 если хотя бы один из соответствующих битов равен 1.
3. Исключающее ИЛИ (XOR, ^): Возвращает 1 если соответствующие биты различны.
4. НЕ (NOT, !): Инвертирует все биты числа.
5. Сдвиг влево (<<): Сдвигает биты числа влево, заполняя освободившиеся биты нулями.
6. Сдвиг вправо (>>): Сдвигает биты числа вправо (для беззнаковых чисел заполняет нулями, для знаковых — зависит от реализации).

Примеры числовых масок

1. Извлечение определённых битов:
   Если нужно извлечь младшие 4 бита числа, можно использовать маску 0b1111 (или 0xF в шестнадцатеричном формате):

   let num = 0b10101010; // Пример числа
   let mask = 0b00001111; // Маска для извлечения младших 4 бит
   let result = num & mask; // Результат: 0b1010
   println!("{:b}", result); // Вывод: 1010

2. Установка битов:
   Чтобы установить определённые биты в 1, используется операция ИЛИ (|):

   let num = 0b10101010;
   let mask = 0b00001111; // Маска для установки младших 4 бит
   let result = num | mask; // Результат: 0b10101111
   println!("{:b}", result); // Вывод: 10101111

3. Сброс битов:
   Чтобы сбросить определённые биты в 0, используется маска с инвертированными битами и операция И (&):

   let num = 0b10101010;
   let mask = !0b00001111; // Инвертированная маска для сброса младших 4 бит
   let result = num & mask; // Результат: 0b10100000
   println!("{:b}", result); // Вывод: 10100000

4. Инвертирование битов:
   Чтобы инвертировать определённые биты, используется операция XOR (^):

   let num = 0b10101010;
   let mask = 0b00001111; // Маска для инвертирования младших 4 бит
   let result = num ^ mask; // Результат: 0b10100101
   println!("{:b}", result); // Вывод: 10100101

5. Проверка битов:
   Чтобы проверить, установлен ли определённый бит, используется маска и операция И (&):

   let num = 0b10101010;
   let mask = 0b00001000; // Маска для проверки 4-го бита
   if num & mask != 0 {
       println!("4-й бит установлен!");
   } else {
       println!("4-й бит не установлен.");
   }

Применение числовых масок

Числовые маски часто используются в следующих сценариях:

• Работа с флагами (например, в системных вызовах или библиотеках).
• Оптимизация памяти (хранение нескольких значений в одном числе).
• Кодирование и декодирование данных.
• Низкоуровневое программирование (например, работа с регистрами микроконтроллеров).

Пример: Хранение флагов

const FLAG_A: u8 = 0b00000001; // Флаг A
const FLAG_B: u8 = 0b00000010; // Флаг B
const FLAG_C: u8 = 0b00000100; // Флаг C

let flags = FLAG_A | FLAG_C; // Устанавливаем флаги A и C

// Проверяем, установлен ли флаг B
if flags & FLAG_B != 0 {
    println!("Флаг B установлен.");
} else {
    println!("Флаг B не установлен.");
}

Заключение

Числовые маски — это мощный инструмент для работы с битами в Rust. Они позволяют эффективно управлять отдельными битами чисел, что особенно полезно в низкоуровневом программировании и оптимизации.

Ошибка может возникать из-за недостатка места, которое необходимо при установке. По умолчанию временные установочные файлы скачиваются в TMPDIR.

Если возникает такая ошибка — то лучше ее переопределить и указать место на диске, в котором достаточно места для скачивания установочных файлов:

export TMPDIR=/home/user/tmp
export TEMPDIR=${TMPDIR}

Затем повторить установку:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

use std::net::TcpStream;
use std::io::Write;
use std::io::Read;
use std::fs::File;
use ssh2::Session;
use std::path::Path;


fn main() {

    let tcp = TcpStream::connect("127.0.0.1:22").unwrap();
    let mut sess = Session::new().unwrap();
sess.set_tcp_stream(tcp);
sess.handshake().unwrap();
sess.userauth_password("user", "pass").unwrap();
     
     let sftp = sess.sftp().unwrap();
     let mut local_file = File::open("/tmp/test.txt").expect("no file found");  
     let mut buffer:Vec<u8> = Vec::new();
     let _ :u64 = local_file.read_to_end(&mut buffer).unwrap().try_into().unwrap();

sftp.create(&Path::new("/tmp/file.json"))
    .unwrap()
    .write_all(&buffer)
    .unwrap();
}

Задача:  вывести счетчик с ведущими нулями, пример 0001, 0002 и т.д.

Задача не сложная, но не стандартная и предполагает несколько вариантов реализации. Мой вариант реализован на том, что мы считаем длину стандартного int счетчика и в зависимости от нее добавляем перед ним нужно количество нулей, которые у нас являются уже строкой.

fn main(){
  
  (1..1002).for_each(|n| {
        let _str: String = n.to_string();
        let lenght = _str.len();    
        let mut _zero = String::from("000");

        if lenght == 2{
            _zero = String::from("00");
        }
        else if lenght == 3{
            _zero = String::from("0");
        }
        else if lenght == 4{
            _zero = String::from("");
        }
    
      println!("{}{}",_zero, n);
});
  
    
}

Реализация этого же через match:

fn main(){
  
  (1..1002).for_each(|n| {
        let _str: String = n.to_string();
        let lenght = _str.len();    
        
    match lenght {
        2 => {println!("00{}", n);}
        3 => {println!("0{}", n);}
        4 => {println!("{}", n);}
        _ => {println!("000{}", n);}
    }
        
    
});
  
    
}