RUST Archives - 12 중 4 번째 페이지

[RUST/COMMON] Box 구조체 : 열거형을 사용해 단방향 연결 리스트 만들기

■ Box<T> 구조체에서 열거형을 사용해 단방향 연결 리스트를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


enum Node
{
    Empty,
    Cons(i64, Box<Node>)
}

use Node::{Empty, Cons};

fn node(data : i64, link : Box<Node>) -> Box<Node>
{
    Box::new(Cons(data, link))
}

fn main()
{
    let first_node_box : Box<Node> = node(10, node(20, node(30, Box::new(Empty))));

    let mut current_pointer : &Box<Node> = &first_node_box;

    loop
    {
        let current_node : &Node = &**current_pointer;

        match current_node
        {
            Empty            => break,
            Cons(data, link) =>
            {
                println!("{}", data);

                current_pointer = &link;
            }
        }
    }
}

/*
10
20
30
*/

enum Node

{

Empty,

Cons(i64, Box<Node>)

}

use Node::{Empty, Cons};

fn node(data : i64, link : Box<Node>) -> Box<Node>

{

Box::new(Cons(data, link))

}

fn main()

{

let first_node_box : Box<Node> = node(10, node(20, node(30, Box::new(Empty))));

let mut current_pointer : &Box<Node> = &first_node_box;

loop

{

let current_node : &Node = &**current_pointer;

match current_node

{

Empty => break,

Cons(data, link) =>

{

println!("{}", data);

current_pointer = &link;

}

[RUST/COMMON] macro_rules! 매크로 : 재귀 호출 매크로 만들기

■ macro_rules! 매크로를 사용해 재귀 호출 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


macro_rules! print_html
{
    () => {()};

    ($e : tt) => {print!("{}", $e)};

    ($tag : ident [$($inner : tt)*] $($rest : tt)*) =>
    {
        {
            print!("<{}>", stringify!($tag));

            print_html!($($inner)*);

            println!("</{}>", stringify!($tag));

            print_html!($($rest)*);
        }
    };
}

fn main()
{
    print_html!
    (
        html
        [
            head[title["test"]]
            body
            [
                h1["test"]
                p ["This is test."]
            ]
        ]
    );
}

/*
<html><head><title>test</title>
</head>
<body><h1>test</h1>
<p>This is test.</p>
</body>
</html>
*/

macro_rules! print_html

{

() => {()};

($e : tt) => {print!("{}", $e)};

($tag : ident [$($inner : tt)*] $($rest : tt)*) =>

{

print!("<{}>", stringify!($tag));

print_html!($($inner)*);

println!("</{}>", stringify!($tag));

print_html!($($rest)*);

}

};

}

fn main()

{

print_html!

(

html

[

head[title["test"]]

body

[

h1["test"]

p ["This is test."]

]

);

}

</head>

</body>

</html>

[RUST/COMMON] macro_rules! 매크로 : 특정 값의 레이블을 구하는 매크로 만들기

■ macro_rules! 매크로를 사용해 특정 값의 레이블을 구하는 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


macro_rules! select_label
{
    ($value : expr, $($source_label : expr => $range : expr);+) =>
    {
        {
            let mut target_label = "";

            $(
                if $range.start <= $value && $value< $range.end
                {
                    target_label = $source_label;
                }
            )+

            target_label
        }
    };
}

fn main()
{
    let label : &str = select_label!
    [
        90,
        "하단" => 0..30;
        "중단" => 30..60;
        "상단" => 60..100
    ];

    println!("결과 : {}", label);
}

/*
결과 : 상단
*/

macro_rules! select_label

{

($value : expr, $($source_label : expr => $range : expr);+) =>

{

let mut target_label = "";

if $range.start <= $value && $value< $range.end

{

target_label = $source_label;

}

target_label

}

};

}

fn main()

{

let label : &str = select_label!

[

90,

"하단" => 0..30;

"중단" => 30..60;

"상단" => 60..100

];

println!("결과 : {}", label);

}

결과 : 상단

[RUST/COMMON] macro_rules! 매크로 : HashMap 객체를 초기화하는 매크로 만들기

■ macro_rules! 매크로를 사용해 HashMap 객체를 초기화하는 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::collections;

macro_rules! map
{
    ($($key : expr => $val : expr), *) =>
    {
        {
            let mut hash_map = collections::HashMap::new();

            $(
                hash_map.insert($key, $val);
            )*

            hash_map
        }
    }
}

fn main()
{
    let hash_map : collections::HashMap<&str, &str> = map!
    [
        "mon" => "월요일",
        "tue" => "화요일",
        "wed" => "수요일",
        "thu" => "목요일",
        "fri" => "금요일",
        "sat" => "토요일",
        "sun" => "일요일"
    ];

    println!("mon = {}", hash_map["mon"]);
    println!("wed = {}", hash_map["wed"]);
}

/*
mon = 월요일
wed = 수요일
*/

use std::collections;

macro_rules! map

{

($($key : expr => $val : expr), *) =>

{

let mut hash_map = collections::HashMap::new();

hash_map.insert($key, $val);

hash_map

}

fn main()

{

let hash_map : collections::HashMap<&str, &str> = map!

[

"mon" => "월요일",

"tue" => "화요일",

"wed" => "수요일",

"thu" => "목요일",

"fri" => "금요일",

"sat" => "토요일",

"sun" => "일요일"

];

println!("mon = {}", hash_map["mon"]);

println!("wed = {}", hash_map["wed"]);

}

mon = 월요일

wed = 수요일

[RUST/COMMON] macro_rules! 매크로 : BASIC 언어의 for문 매크로 만들기

■ macro_rules! 매크로를 사용해 BASIC 언어의 for문 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


macro_rules! basic_for
{
    (
        for $i:ident = $from:tt to $to:tt $block:block
    ) =>
    {
        {
            for $i in $from..=$to
            {
                $block;
            }
        }
    };

    (
        for $i:ident = $from:tt to $to:tt step $step:tt $block:block
    ) =>
    {
        {
            let mut $i = $from;

            loop
            {
                if $i > $to
                {
                    break;
                }

                $block;

                $i += $step;
            }
        }
    };
}

fn main()
{
    let mut total : i32 = 0;

    basic_for!
    {
        for i = 1 to 10
        {
            total += i;
        }
    }

    println!("{}", total);

    basic_for!
    {
        for i = 0 to 10 step 3
        {
            println!("i = {}", i);
        }
    }
}

/*
55
i = 0
i = 3
i = 6
i = 9
*/

macro_rules! basic_for

{

(

for $i:ident = $from:tt to $to:tt $block:block

) =>

{

for $i in $from..=$to

{

$block;

}

};

(

for $i:ident = $from:tt to $to:tt step $step:tt $block:block

) =>

{

let mut $i = $from;

loop

{

if $i > $to

{

break;

}

$block;

$i += $step;

}

};

}

fn main()

{

let mut total : i32 = 0;

basic_for!

{

for i = 1 to 10

{

total += i;

}

println!("{}", total);

basic_for!

{

for i = 0 to 10 step 3

{

println!("i = {}", i);

}

i = 0

i = 3

i = 6

i = 9

[RUST/COMMON] macro_rules! 매크로 : 가변 인수 매크로 만들기

■ macro_rules! 매크로를 사용해 가변 인수 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


#[macro_export]
macro_rules! echo_numbers
{
    ($($number : expr), *) =>
    {
        $(
            print!("{}, ", $number);
        )*

        println!("");
    }
}

fn main()
{
    echo_numbers![10, 20, 30, 40, 50];
    echo_numbers!(60, 70);
    echo_numbers!{80, 90, 100};
}

/*
10, 20, 30, 40, 50,
60, 70,
80, 90, 100,
*/

#[macro_export]

macro_rules! echo_numbers

{

($($number : expr), *) =>

{

print!("{}, ", $number);

println!("");

}

fn main()

{

echo_numbers![10, 20, 30, 40, 50];

echo_numbers!(60, 70);

echo_numbers!{80, 90, 100};

}

10, 20, 30, 40, 50,

60, 70,

80, 90, 100,

[RUST/COMMON] marco_rules! 매크로 : 매크로 만들기

■ marco_rules! 매크로를 사용해 매크로를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


macro_rules! echo_number
{
    ($number : expr) => { println!("{}", $number); }
}

fn main()
{
    echo_number!(10);
    echo_number![20];
    echo_number!{30};
}

/*
10
20
30
*/

macro_rules! echo_number

{

($number : expr) => { println!("{}", $number); }

}

fn main()

{

echo_number!(10);

echo_number![20];

echo_number!{30};

}

[RUST/TIDE] tide 크레이트를 사용해 값 입력 웹 서버 만들기

■ tide 크레이트를 사용해 값을 입력받는 웹 서버를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_server"
version = "0.1.0"
edition = "2021"

[dependencies]
tide = "0.16"
async-std = {version = "1.8.0", features = ["attributes"]}
serde = {version = "1.0", features = ["derive"]}

[package]

name = "test_server"

version = "0.1.0"

edition = "2021"

[dependencies]

tide = "0.16"

async-std = {version = "1.8.0", features = ["attributes"]}

serde = {version = "1.0", features = ["derive"]}

▶ src/main.rs


use tide::prelude::*;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[derive(Deserialize, Serialize)]
struct UserInformation
{
    name : String
}

#[async_std::main]
async fn main() -> tide::Result<()>
{
    println!("http://{}/", SERVER_ADDRESS);

    let mut server : tide::Server<()> = tide::new();

    server.at("/")
        .get
        (
            |_| async
            {
                Ok
                (
                    tide::Response::builder(200)
                    .content_type(tide::http::mime::HTML)
                    .body
                    (
r#"<html>
<body>
<form action='hello'>
name : <input name='name' value='홍길동'>
<input type='submit' value='전송'>
</form>
</body>
</html>"#
                    )
                    .build()
                )
            }
        );

    server.at("/hello")
        .get
        (
            |request : tide::Request<()>| async move
            {
                let user_information : UserInformation = request.query()?;

                return Ok
                (
                    tide::Response::builder(200)
                        .content_type(tide::http::mime::HTML)
                        .body(format!("<h1>안녕하세요, {}님</h1>", user_information.name))
                        .build()
                );
            }
        );

    server.listen(SERVER_ADDRESS).await?;

    return Ok(());
}

use tide::prelude::*;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[derive(Deserialize, Serialize)]

struct UserInformation

{

name : String

}

#[async_std::main]

async fn main() -> tide::Result<()>

{

println!("http://{}/", SERVER_ADDRESS);

let mut server : tide::Server<()> = tide::new();

server.at("/")

.get

(

|_| async

{

(

tide::Response::builder(200)

.content_type(tide::http::mime::HTML)

.body

(

r#"<html>

<body>

name : <input name='name' value='홍길동'>

</form>

</body>

</html>"#

)

.build()

)

}

);

server.at("/hello")

.get

(

|request : tide::Request<()>| async move

{

let user_information : UserInformation = request.query()?;

return Ok

(

tide::Response::builder(200)

.content_type(tide::http::mime::HTML)

.body(format!("<h1>안녕하세요, {}님</h1>", user_information.name))

.build()

);

}

);

server.listen(SERVER_ADDRESS).await?;

return Ok(());

}

test_server.zip

[RUST/TIDE] tide 크레이트를 사용해 단순 웹 서버 만들기

■ tide 크레이트를 사용해 단순 웹 서버를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_server"
version = "0.1.0"
edition = "2021"

[dependencies]
tide = "0.16"
async-std = {version = "1.8.0", features = ["attributes"]}

[package]

name = "test_server"

version = "0.1.0"

edition = "2021"

[dependencies]

tide = "0.16"

async-std = {version = "1.8.0", features = ["attributes"]}

▶ src/main.rs


const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[async_std::main]
async fn main() -> tide::Result<()>
{
    println!("http://{}/", SERVER_ADDRESS);

    let mut server : tide::Server<()> = tide::new();

    server.at("/").get
    (
        |_| async
        {
            return Ok("Hello, World!");
        }
    );

    server.listen(SERVER_ADDRESS).await?;

    return Ok(());
}

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[async_std::main]

async fn main() -> tide::Result<()>

{

println!("http://{}/", SERVER_ADDRESS);

let mut server : tide::Server<()> = tide::new();

server.at("/").get

(

|_| async

{

return Ok("Hello, World!");

}

);

server.listen(SERVER_ADDRESS).await?;

return Ok(());

}

test_server.zip

[RUST/COMMON] 크레이트 설치 : async-std

■ async-std 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
async-std = {version = "1.8.0", features = ["attributes"]}

...

[dependencies]

async-std = {version = "1.8.0", features = ["attributes"]}

[RUST/COMMON] 크레이트 설치 : tide

■ tide 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
tide = "0.16"

...

[dependencies]

tide = "0.16"

[RUST/ACTIX-WEB] Actix Web 프레임워크를 사용해 BMI 판정 웹 서버 만들기

■ Actix Web 프레임워크를 사용해 BMI 판정 웹 서버를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_server"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "3"
serde = "1.0"

[package]

name = "test_server"

version = "0.1.0"

edition = "2021"

[dependencies]

actix-web = "3"

serde = "1.0"

▶ src/main.rs


use std::io;

use actix_web::web;
use serde;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[actix_web::main]
async fn main() -> io::Result<()>
{
    println!("[서버] http://{}/", SERVER_ADDRESS);

    actix_web::HttpServer::new
    (
        ||
        {
            actix_web::App::new()
                .service(index)
                .service(calculate)
        }
    )
    .bind(SERVER_ADDRESS)?
    .run()
    .await
}

#[actix_web::get("/")]
async fn index(_ : actix_web::HttpRequest) -> Result<actix_web::HttpResponse, actix_web::Error>
{
    return Ok
    (
        actix_web::HttpResponse::Ok()
            .content_type("text/html; charset=utf-8")
            .body
            (
r#"
<html>
<body>
<h1>BMI 계산 및 비만도 판정</h1>
<form action='calculate'>
<div>키 : <div><label><input name='height' value='160'></label></div></div>
<div>몸무게 : <div><label><input name='weight' value='70'></label></div></div>
<div><label><input type='submit' value='확인'></label></div>
</form>
</body>
</html>
"#
            )
    );
}

#[derive(serde::Deserialize, Debug)]
pub struct BMI
{
    height : f64,
    weight : f64,
}

#[actix_web::get("/calculate")]
async fn calculate(bmi : web::Query<BMI>) -> Result<actix_web::HttpResponse, actix_web::Error>
{
    println!("{:?}", bmi);

    let temporary_height : f64 = bmi.height / 100.0;
    let bmi              : f64 = bmi.weight / (temporary_height * temporary_height);
    let bmi_percentage   : f64 = (bmi / 22.0) * 100.0;

    return Ok(actix_web::HttpResponse::Ok()
        .content_type("text/html; charset=utf-8")
        .body(format!("<h3>BMI = {:.1}, 비만율 = {:.0}%</h3>", bmi, bmi_percentage)));
}

use std::io;

use actix_web::web;

use serde;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[actix_web::main]

async fn main() -> io::Result<()>

{

println!("[서버] http://{}/", SERVER_ADDRESS);

actix_web::HttpServer::new

(

{

actix_web::App::new()

.service(index)

.service(calculate)

}

)

.bind(SERVER_ADDRESS)?

.run()

.await

}

#[actix_web::get("/")]

async fn index(_ : actix_web::HttpRequest) -> Result<actix_web::HttpResponse, actix_web::Error>

{

return Ok

(

actix_web::HttpResponse::Ok()

.content_type("text/html; charset=utf-8")

.body

(

r#"

<html>

<body>

</form>

</body>

</html>

)

);

}

#[derive(serde::Deserialize, Debug)]

pub struct BMI

{

height : f64,

weight : f64,

}

#[actix_web::get("/calculate")]

async fn calculate(bmi : web::Query<BMI>) -> Result<actix_web::HttpResponse, actix_web::Error>

{

println!("{:?}", bmi);

let temporary_height : f64 = bmi.height / 100.0;

let bmi : f64 = bmi.weight / (temporary_height * temporary_height);

let bmi_percentage : f64 = (bmi / 22.0) * 100.0;

return Ok(actix_web::HttpResponse::Ok()

.content_type("text/html; charset=utf-8")

.body(format!("<h3>BMI = {:.1}, 비만율 = {:.0}%</h3>", bmi, bmi_percentage)));

}

test_server.zip

[RUST/COMMON] 크레이트 설치 : serde

■ serde 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
serde = "1.0"

또는

serde = {version = "1.0", features = ["derive"]}

...

[dependencies]

serde = "1.0"

또는

serde = {version = "1.0", features = ["derive"]}

[RUST/ACTIX-WEB] Actix Web 프레임워크를 사용해 단순 웹 서버 만들기

■ Actix Web 프레임워크를 사용해 단순 웹 서버를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_server"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "3"

[package]

name = "test_server"

version = "0.1.0"

edition = "2021"

[dependencies]

actix-web = "3"

▶ src/main.rs


use actix_web;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[actix_web::main]
async fn main() -> Result<(), actix_web::Error>
{
    println!("[서버] http://{}/", SERVER_ADDRESS);

    actix_web::HttpServer::new
    (
        ||
        {
            actix_web::App::new().route("/", actix_web::web::get().to(index))
        }
    )
    .bind(SERVER_ADDRESS)?
    .run()
    .await?;

    return Ok(());
}

async fn index(request : actix_web::HttpRequest) -> Result<actix_web::HttpResponse, actix_web::Error>
{
    println!("요청 : {:?}", request);

    let result : &str = "안녕하세요.";

    Ok(actix_web::HttpResponse::Ok().body(result))
}

use actix_web;

const SERVER_ADDRESS : &str = "127.0.0.1:8888";

#[actix_web::main]

async fn main() -> Result<(), actix_web::Error>

{

println!("[서버] http://{}/", SERVER_ADDRESS);

actix_web::HttpServer::new

(

{

actix_web::App::new().route("/", actix_web::web::get().to(index))

}

)

.bind(SERVER_ADDRESS)?

.run()

.await?;

return Ok(());

}

async fn index(request : actix_web::HttpRequest) -> Result<actix_web::HttpResponse, actix_web::Error>

{

println!("요청 : {:?}", request);

let result : &str = "안녕하세요.";

Ok(actix_web::HttpResponse::Ok().body(result))

}

test_server.zip

[RUST/COMMON] 크레이트 설치 : actix-web

■ actix-web 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
actix-web = "3"

...

[dependencies]

actix-web = "3"

[RUST/COMMON] TCP 프로토콜을 사용해 간이 채팅 프로그램 만들기

■ TCP 프로토콜을 사용해 간이 채팅 프로그램을 만드는 방법을 보여준다. [test_server 프로젝트] ▶ src/main.rs


use std::io;
use std::io::BufRead;
use std::io::Write;
use std::net;
use std::sync::mpsc;
use std::thread;
use std::time;

fn main()
{
    let server_address : &str = "127.0.0.1:8888";

    let (tx, rx) = mpsc::channel::<String>();

    let mut tcp_stream_vector : Vec<net::TcpStream> = Vec::new();

    let tcp_listener : net::TcpListener = net::TcpListener::bind(server_address).expect("서버 실행시 에러가 발생했습니다.");

    tcp_listener.set_nonblocking(true).expect("넌블로킹 모드 설정시 에러가 발생했습니다.");

    println!("서버 실행이 시작되었습니다 : {}", server_address);

    loop
    {
        if let Ok((client, client_address)) = tcp_listener.accept()
        {
            println!("클라이언트가 접속했습니다 : {}", client_address);

            tcp_stream_vector.push(client.try_clone().unwrap());

            start_thread(client, tx.clone());
        }

        if let Ok(client_message) = rx.try_recv()
        {
            println!("모든 클라기언트에게 메시지 전송 : {}", client_message.trim());

            tcp_stream_vector = reply_to_all_clients(tcp_stream_vector, &client_message);
        }

        thread::sleep(time::Duration::from_millis(100));
    }
}

fn start_thread(tcp_stream : net::TcpStream, tx : mpsc::Sender<String>)
{
    let mut buf_reader : io::BufReader<net::TcpStream> = io::BufReader::new(tcp_stream);

    thread::spawn
    (
        move ||
        {
            loop
            {
                let mut message : String = String::new();

                if let Ok(byte_count_read) = buf_reader.read_line(&mut message)
                {
                    if byte_count_read > 0
                    {
                        tx.send(message).unwrap();
                    }
                }

                thread::sleep(time::Duration::from_millis(100));
            }
        }
    );
}

fn reply_to_all_clients(tcp_stream_vector : Vec<net::TcpStream>, message : &str) -> Vec<net::TcpStream>
{
    let mut new_tcp_stream_vector : Vec<net::TcpStream> = vec![];

    for mut tcp_stream in tcp_stream_vector.into_iter()
    {
        let message_byte_vector : Vec<u8> = String::from(message).into_bytes();

        if let Err(e) = tcp_stream.write_all(&message_byte_vector)
        {
            println!("전송시 에러가 발생했습니다 : {}", e);

            continue;
        }

        new_tcp_stream_vector.push(tcp_stream);
    }

    return new_tcp_stream_vector;
}

use std::io;

use std::io::BufRead;

use std::io::Write;

use std::net;

use std::sync::mpsc;

use std::thread;

use std::time;

fn main()

{

let server_address : &str = "127.0.0.1:8888";

let (tx, rx) = mpsc::channel::<String>();

let mut tcp_stream_vector : Vec<net::TcpStream> = Vec::new();

let tcp_listener : net::TcpListener = net::TcpListener::bind(server_address).expect("서버 실행시 에러가 발생했습니다.");

tcp_listener.set_nonblocking(true).expect("넌블로킹 모드 설정시 에러가 발생했습니다.");

println!("서버 실행이 시작되었습니다 : {}", server_address);

loop

{

if let Ok((client, client_address)) = tcp_listener.accept()

{

println!("클라이언트가 접속했습니다 : {}", client_address);

tcp_stream_vector.push(client.try_clone().unwrap());

start_thread(client, tx.clone());

}

if let Ok(client_message) = rx.try_recv()

{

println!("모든 클라기언트에게 메시지 전송 : {}", client_message.trim());

tcp_stream_vector = reply_to_all_clients(tcp_stream_vector, &client_message);

}

thread::sleep(time::Duration::from_millis(100));

}

fn start_thread(tcp_stream : net::TcpStream, tx : mpsc::Sender<String>)

{

let mut buf_reader : io::BufReader<net::TcpStream> = io::BufReader::new(tcp_stream);

thread::spawn

(

move ||

{

loop

{

let mut message : String = String::new();

if let Ok(byte_count_read) = buf_reader.read_line(&mut message)

{

if byte_count_read > 0

{

tx.send(message).unwrap();

}

thread::sleep(time::Duration::from_millis(100));

}

);

}

fn reply_to_all_clients(tcp_stream_vector : Vec<net::TcpStream>, message : &str) -> Vec<net::TcpStream>

{

let mut new_tcp_stream_vector : Vec<net::TcpStream> = vec![];

for mut tcp_stream in tcp_stream_vector.into_iter()

{

let message_byte_vector : Vec<u8> = String::from(message).into_bytes();

if let Err(e) = tcp_stream.write_all(&message_byte_vector)

{

println!("전송시 에러가 발생했습니다 : {}", e);

continue;

}

new_tcp_stream_vector.push(tcp_stream);

}

return new_tcp_stream_vector;

}

[test_client 프로젝트] ▶ src/main.rs


use std::io;
use std::io::BufRead;
use std::io::Write;
use std::net;
use std::thread;
use std::time;

fn main()
{
    let server_addresss : &str = "127.0.0.1:8888";

    let mut tcp_stream : net::TcpStream = net::TcpStream::connect(server_addresss).expect("서버 접속시 에러가 발생했습니다.");

    tcp_stream.set_nonblocking(true).expect("넌블로킹 모드 설정시 에러가 발생했습니다.");

    println!("서버에 접속했습니다 : {}", server_addresss);

    start_thread(tcp_stream.try_clone().unwrap());

    let user_name : String = input("사용자명을 입력해 주시기 바랍니다.");

    println!("{}님 메시지를 입력해 주시기 바랍니다.", user_name);

    loop
    {
        let message : String = input("");

        let message : String = format!("{} > {}\n", user_name, message);

        let message_byte_array : &[u8] = message.as_bytes();

        tcp_stream.write_all(message_byte_array).unwrap();
    }
}

fn start_thread(tcp_stream : net::TcpStream)
{
    let mut reader : io::BufReader<net::TcpStream> = io::BufReader::new(tcp_stream);

    thread::spawn
    (
        move ||
        {
            loop
            {
                let mut message : String = String::new();

                if let Ok(byte_count_read) = reader.read_line(&mut message)
                {
                    if byte_count_read > 0
                    {
                        println!("입력 메시지 : {}", message.trim());
                    }
                }

                thread::sleep(time::Duration::from_millis(100));
            }
        }
    );
}

fn input(display_message : &str) -> String
{
    if display_message != ""
    {
        println!("{}", display_message);
    }

    let mut input_message : String = String::new();

    io::stdin().read_line(&mut input_message).expect("메시지 입력시 에러가 발생했습니다.");

    return String::from(input_message.trim());
}

use std::io;

use std::io::BufRead;

use std::io::Write;

use std::net;

use std::thread;

use std::time;

fn main()

{

let server_addresss : &str = "127.0.0.1:8888";

let mut tcp_stream : net::TcpStream = net::TcpStream::connect(server_addresss).expect("서버 접속시 에러가 발생했습니다.");

tcp_stream.set_nonblocking(true).expect("넌블로킹 모드 설정시 에러가 발생했습니다.");

println!("서버에 접속했습니다 : {}", server_addresss);

start_thread(tcp_stream.try_clone().unwrap());

let user_name : String = input("사용자명을 입력해 주시기 바랍니다.");

println!("{}님 메시지를 입력해 주시기 바랍니다.", user_name);

loop

{

let message : String = input("");

let message : String = format!("{} > {}\n", user_name, message);

let message_byte_array : &[u8] = message.as_bytes();

tcp_stream.write_all(message_byte_array).unwrap();

}

fn start_thread(tcp_stream : net::TcpStream)

{

let mut reader : io::BufReader<net::TcpStream> = io::BufReader::new(tcp_stream);

thread::spawn

(

move ||

{

loop

{

let mut message : String = String::new();

if let Ok(byte_count_read) = reader.read_line(&mut message)

{

if byte_count_read > 0

{

println!("입력 메시지 : {}", message.trim());

}

thread::sleep(time::Duration::from_millis(100));

}

);

}

fn input(display_message : &str) -> String

{

if display_message != ""

{

println!("{}", display_message);

}

let mut input_message : String = String::new();

io::stdin().read_line(&mut input_message).expect("메시지 입력시 에러가 발생했습니다.");

return String::from(input_message.trim());

}

test_server.zip test_client.zip

[RUST/COMMON] spawn 함수 : 쓰레드로 병렬 계산 처리하기

■ spawn 함수를 사용해 쓰레드로 병렬 계산을 처리하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::sync::mpsc;
use std::thread;
use std::time;

fn main()
{
    let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

    let instant : time::Instant = time::Instant::now();

    let (tx, rx) = mpsc::channel::<(i64, i64)>();

    for index in index_array
    {
        let sender : mpsc::Sender<(i64, i64)> = tx.clone();

        thread::spawn
        (
            move ||
            {
                let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

                sender.send((index, fibonacci_sequence)).unwrap();
            }
        );
    }

    let mut job_count : usize = index_array.len();

    loop
    {
        if let Ok((index, fibonacci_sequence)) = rx.recv()
        {
            job_count -= 1;

            println!("[결과] (남은 계산 : {}) {} 번째 피보나치 수 : {} ", job_count, index, fibonacci_sequence);

            if job_count <= 0
            {
                let duration : time::Duration = instant.elapsed();

                println!("실행 시간 : {:?}", duration);

                break;
            }
        }

        thread::sleep(time::Duration::from_millis(300));
    }
}

fn calculate_fibonacci_sequence(index : i64) -> i64
{
    if index == 1
    {
        return 0;
    }

    if index == 2
    {
        return 1;
    }

    return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);
}

use std::sync::mpsc;

use std::thread;

use std::time;

fn main()

{

let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

let instant : time::Instant = time::Instant::now();

let (tx, rx) = mpsc::channel::<(i64, i64)>();

for index in index_array

{

let sender : mpsc::Sender<(i64, i64)> = tx.clone();

thread::spawn

(

move ||

{

let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

sender.send((index, fibonacci_sequence)).unwrap();

}

);

}

let mut job_count : usize = index_array.len();

loop

{

if let Ok((index, fibonacci_sequence)) = rx.recv()

{

job_count -= 1;

println!("[결과] (남은 계산 : {}) {} 번째 피보나치 수 : {} ", job_count, index, fibonacci_sequence);

if job_count <= 0

{

let duration : time::Duration = instant.elapsed();

println!("실행 시간 : {:?}", duration);

break;

}

thread::sleep(time::Duration::from_millis(300));

}

fn calculate_fibonacci_sequence(index : i64) -> i64

{

if index == 1

{

return 0;

}

if index == 2

{

return 1;

}

return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);

}

[RUST/COMMON] Instant 구조체 : elapsed 메소드를 사용해 실행 시간 측정하기

■ Instant 구조체의 elapsed 메소드를 사용해 실행 시간을 측정하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::time;

fn main()
{
    let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

    let instant : time::Instant = time::Instant::now();

    for index in index_array
    {
        let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

        println!("[결과] fib({} 번째 수) = {}", index, fibonacci_sequence);
    }

    let duration : time::Duration = instant.elapsed();

    println!("실행 시간 : {:?}", duration);
}

fn calculate_fibonacci_sequence(index : i64) -> i64
{
    if index == 1
    {
        return 0;
    }

    if index == 2
    {
        return 1;
    }

    return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);
}

use std::time;

fn main()

{

let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

let instant : time::Instant = time::Instant::now();

for index in index_array

{

let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

println!("[결과] fib({} 번째 수) = {}", index, fibonacci_sequence);

}

let duration : time::Duration = instant.elapsed();

println!("실행 시간 : {:?}", duration);

}

fn calculate_fibonacci_sequence(index : i64) -> i64

{

if index == 1

{

return 0;

}

if index == 2

{

return 1;

}

return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);

}

[RUST/COMMON] MPSC 채널 메커니즘을 사용해 스레드 간 데이터 공유하기

■ MPSC 채널 메커니즘을 사용해 스레드 간 데이터 공유하기 ▶ 예제 코드 (RS)


use std::sync::mpsc;
use std::thread;
use std::time;

fn send_message(source_message : &str, sender : mpsc::Sender<String>)
{
    let message_array : [&str; 5] = ["메시지 1", "메시지 2", "메시지 3", "메시지 4", "메시지 5"];

    for message in message_array
    {
        let target_message : String = format!("{} : {}", source_message, message);

        sender.send(target_message).unwrap();

        thread::sleep(time::Duration::from_millis(1000));
    }

    sender.send("중단".to_string()).unwrap();
}

fn main()
{
    let (tx, rx) = mpsc::channel::<String>();

    let sender1 : mpsc::Sender<String> = tx.clone();

    thread::spawn(|| { send_message("스레드 1", sender1); });

    let sender2 : mpsc::Sender<String> = tx.clone();

    thread::spawn(|| { send_message("스레드 2", sender2) });

    loop
    {
        let message : String = rx.recv().unwrap();

        println!("[수신] {}", message);

        if message == "중단"
        {
            break;
        }
    }
}

/*
[수신] 스레드 1 : 메시지 1
[수신] 스레드 2 : 메시지 1
[수신] 스레드 2 : 메시지 2
[수신] 스레드 1 : 메시지 2
[수신] 스레드 1 : 메시지 3
[수신] 스레드 2 : 메시지 3
[수신] 스레드 1 : 메시지 4
[수신] 스레드 2 : 메시지 4
[수신] 스레드 1 : 메시지 5
[수신] 스레드 2 : 메시지 5
[수신] 중단
*/

use std::sync::mpsc;

use std::thread;

use std::time;

fn send_message(source_message : &str, sender : mpsc::Sender<String>)

{

let message_array : [&str; 5] = ["메시지 1", "메시지 2", "메시지 3", "메시지 4", "메시지 5"];

for message in message_array

{

let target_message : String = format!("{} : {}", source_message, message);

sender.send(target_message).unwrap();

thread::sleep(time::Duration::from_millis(1000));

}

sender.send("중단".to_string()).unwrap();

}

fn main()

{

let (tx, rx) = mpsc::channel::<String>();

let sender1 : mpsc::Sender<String> = tx.clone();

thread::spawn(|| { send_message("스레드 1", sender1); });

let sender2 : mpsc::Sender<String> = tx.clone();

thread::spawn(|| { send_message("스레드 2", sender2) });

loop

{

let message : String = rx.recv().unwrap();

println!("[수신] {}", message);

if message == "중단"

{

break;

}

[수신] 스레드 1 : 메시지 1

[수신] 스레드 2 : 메시지 1

[수신] 스레드 2 : 메시지 2

[수신] 스레드 1 : 메시지 2

[수신] 스레드 1 : 메시지 3

[수신] 스레드 2 : 메시지 3

[수신] 스레드 1 : 메시지 4

[수신] 스레드 2 : 메시지 4

[수신] 스레드 1 : 메시지 5

[수신] 스레드 2 : 메시지 5

[수신] 중단

[RUST/COMMON] channel 함수 : MPSC 채널 객체 생성하기

■ channel 함수를 사용해 MPSC 채널 객체를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::sync::mpsc;

let (tx, rx) = mpsc::channel::<String>();

use std::sync::mpsc;

let (tx, rx) = mpsc::channel::<String>();

[RUST/COMMON] Duration 구조체 : from_millis 연관 함수를 사용해 1000 밀리초 Duration 객체 구하기

■ Duration 구조체의 from_millis 연관 함수를 사용해 1000 밀리초의 Duration 객체를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::time;

let dureation : time::Duration = time::Duration::from_millis(1000);

use std::time;

let dureation : time::Duration = time::Duration::from_millis(1000);

[RUST/COMMON] spawn 함수 : 쓰레드 생성하기

■ spawn 함수를 사용해 쓰레드를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::thread;
use std::time;

fn print_message(message : &str)
{
    for i in 1..=3
    {
        println!("{} : i = {}", message, i);

        thread::sleep(time::Duration::from_millis(1000));
    }
}

fn main()
{
    print_message("메인 스레드 1");

    thread::spawn(|| { print_message("스레드 1"); });

    thread::spawn(|| { print_message("스레드 2"); });

    thread::spawn(|| { print_message("스레드 3"); });

    print_message("메인 스레드 2");
}

/*
메인 스레드 1 : i = 1
메인 스레드 1 : i = 2
메인 스레드 1 : i = 3
메인 스레드 2 : i = 1
스레드 1 : i = 1
스레드 2 : i = 1
스레드 3 : i = 1
스레드 1 : i = 2
메인 스레드 2 : i = 2
스레드 3 : i = 2
스레드 2 : i = 2
메인 스레드 2 : i = 3
스레드 3 : i = 3
스레드 1 : i = 3
스레드 2 : i = 3
*/

use std::thread;

use std::time;

fn print_message(message : &str)

{

for i in 1..=3

{

println!("{} : i = {}", message, i);

thread::sleep(time::Duration::from_millis(1000));

}

fn main()

{

print_message("메인 스레드 1");

thread::spawn(|| { print_message("스레드 1"); });

thread::spawn(|| { print_message("스레드 2"); });

thread::spawn(|| { print_message("스레드 3"); });

print_message("메인 스레드 2");

}

메인 스레드 1 : i = 1

메인 스레드 1 : i = 2

메인 스레드 1 : i = 3

메인 스레드 2 : i = 1

스레드 1 : i = 1

스레드 2 : i = 1

스레드 3 : i = 1

스레드 1 : i = 2

메인 스레드 2 : i = 2

스레드 3 : i = 2

스레드 2 : i = 2

메인 스레드 2 : i = 3

스레드 3 : i = 3

스레드 1 : i = 3

스레드 2 : i = 3

[RUST/COMMON] sleep 함수 : 쓰레드 대기하기

■ sleep 함수를 사용해 쓰레드를 대기하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::thread;
use std::time;

thread::sleep(time::Duration::from_millis(1000));

use std::thread;

use std::time;

thread::sleep(time::Duration::from_millis(1000));

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 FM(Frequency Modulation) 음원 WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 FM(Frequency Modulation) 음원의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/fm.rs


use std::f32::consts;

pub const SAMPLE_RATE : f32 = 44100.0;

pub struct Note
{
    pub scale  : i32,       // 음계
    pub length : isize,     // 음표 길이
    pub gain   : f32,       // 음량
    pub params : (f32, f32) // 음색 매개변수
}

pub fn make_fm(wave_vector : &mut Vec<f32>, note : Note)
{
    let frequency : f32 = get_frequency(note.scale);

    let a : f32 = 2.0 * consts::PI * frequency / SAMPLE_RATE;

    let wave_vector_length : usize = note.length as usize;

    let mut temporary_wave_vector1 :Vec<f32> = vec![0.0; wave_vector_length];

    for i in 0..(note.length as usize)
    {
        let t : f32 = i as f32;

        let sin1 : f32 = note.params.0 * (a * t).sin();
        let sin2 : f32 = note.params.1 * (a * t + sin1).sin();
        let sin3 : f32 = (a * t + sin2).sin();

        temporary_wave_vector1[i] = sin3;
    }

    let attack  : usize = 3;
    let decay   : usize = attack + 200;
    let sustain : f32 = 0.90;
    let release : usize = (wave_vector_length as f32 * 0.4) as usize;

    let temporary_wave_vector2 : Vec<f32> = temporary_wave_vector1.into_iter().enumerate().map
    (
        |(index, value)|
        {
            let v1 : f32 = (value * note.gain) as f32;

            if index < attack { return index as f32 / attack as f32 * v1; }

            let v2 : f32 = v1 * sustain;

            if index < decay
            {
                let dec : f32 = (1.0 - (index as f32 / decay as f32)) * (1.0 - sustain) * v1.abs();

                return if v2 > 0.0 { v1 + dec } else { v1 - dec }
            }
            else if index > (wave_vector_length - release)
            {
                let i : usize = index - (wave_vector_length - release);

                return (1.0 - i as f32 / release as f32) * v2;
            }

            return v2;
        }
    ).collect();

    wave_vector.extend(temporary_wave_vector2);

}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
pub fn calculate_note_length(bpm : usize, note : usize) -> isize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as isize;
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

use std::f32::consts;

pub const SAMPLE_RATE : f32 = 44100.0;

pub struct Note

{

pub scale : i32, // 음계

pub length : isize, // 음표 길이

pub gain : f32, // 음량

pub params : (f32, f32) // 음색 매개변수

}

pub fn make_fm(wave_vector : &mut Vec<f32>, note : Note)

{

let frequency : f32 = get_frequency(note.scale);

let a : f32 = 2.0 * consts::PI * frequency / SAMPLE_RATE;

let wave_vector_length : usize = note.length as usize;

let mut temporary_wave_vector1 :Vec<f32> = vec![0.0; wave_vector_length];

for i in 0..(note.length as usize)

{

let t : f32 = i as f32;

let sin1 : f32 = note.params.0 * (a * t).sin();

let sin2 : f32 = note.params.1 * (a * t + sin1).sin();

let sin3 : f32 = (a * t + sin2).sin();

temporary_wave_vector1[i] = sin3;

}

let attack : usize = 3;

let decay : usize = attack + 200;

let sustain : f32 = 0.90;

let release : usize = (wave_vector_length as f32 * 0.4) as usize;

let temporary_wave_vector2 : Vec<f32> = temporary_wave_vector1.into_iter().enumerate().map

(

|(index, value)|

{

let v1 : f32 = (value * note.gain) as f32;

if index < attack { return index as f32 / attack as f32 * v1; }

let v2 : f32 = v1 * sustain;

if index < decay

{

let dec : f32 = (1.0 - (index as f32 / decay as f32)) * (1.0 - sustain) * v1.abs();

return if v2 > 0.0 { v1 + dec } else { v1 - dec }

}

else if index > (wave_vector_length - release)

{

let i : usize = index - (wave_vector_length - release);

return (1.0 - i as f32 / release as f32) * v2;

}

return v2;

}

).collect();

wave_vector.extend(temporary_wave_vector2);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

pub fn calculate_note_length(bpm : usize, note : usize) -> isize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as isize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

▶ src/main.rs

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 펄스파(pulse wave) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 펄스파(pulse wave)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/pulse.wav", wav_spec).unwrap();

    let mut wave_vector : Vec<f32> = vec![];

    let bpm : usize = 120;

    [0.3, 0.1, 0.7, 0.5].iter().for_each
    (
        |duty : &f32|
        {
            [60, 64, 67, 72].iter().for_each
            (
                |scale : &i32|
                {
                    wave_vector.extend(get_pulse_wave_vector(*scale, calculate_note_length(bpm, 4), 0.5, *duty));
                }
            );
        }
    );

    for value in wave_vector.into_iter()
    {
        wav_writer.write_sample(value).unwrap();
    }
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note : usize) -> usize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;
}

// scale       : 음계, 예) 60(도), 64(미), 67(솔)
// note_length : 음표 길이 (샘플 수)
// gain        : 출력
// duty        : 듀티
fn get_pulse_wave_vector(scale : i32, note_length : usize, gain : f32, duty : f32) -> Vec<f32>
{
    let frequency : f32 = get_frequency(scale);

    let interval : f32 = SAMPLE_RATE / frequency;

    let mut wave_vector : Vec<f32> = vec![0.0; note_length];

    for i in 0..note_length
    {
        let saw : f32 = (i as f32 / interval) % 1.0;

        wave_vector[i] = if saw > duty { -1.0 } else { 1.0 };
    }

    return wave_vector.into_iter().map(|v: f32| (v * gain) as f32).collect();
}

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/pulse.wav", wav_spec).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

[0.3, 0.1, 0.7, 0.5].iter().for_each

(

|duty : &f32|

{

[60, 64, 67, 72].iter().for_each

(

|scale : &i32|

{

wave_vector.extend(get_pulse_wave_vector(*scale, calculate_note_length(bpm, 4), 0.5, *duty));

}

);

}

);

for value in wave_vector.into_iter()

{

wav_writer.write_sample(value).unwrap();

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note : usize) -> usize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

// note_length : 음표 길이 (샘플 수)

// gain : 출력

// duty : 듀티

fn get_pulse_wave_vector(scale : i32, note_length : usize, gain : f32, duty : f32) -> Vec<f32>

{

let frequency : f32 = get_frequency(scale);

let interval : f32 = SAMPLE_RATE / frequency;

let mut wave_vector : Vec<f32> = vec![0.0; note_length];

for i in 0..note_length

{

let saw : f32 = (i as f32 / interval) % 1.0;

wave_vector[i] = if saw > duty { -1.0 } else { 1.0 };

}

return wave_vector.into_iter().map(|v: f32| (v * gain) as f32).collect();

}

test_project.zip