Merge branch 'main' into main

Author: iamkisly

README.md

@@ -72,9 +72,9 @@ _The 1st step is to build source code from various of languages_
 ```bash
 cd bench
 # To build a subset
-dotnet run -p tool -- --task build --langs lisp go --problems nbody helloworld --force-rebuild
+dotnet run --project tool -- --task build --langs lisp go --problems nbody helloworld --force-rebuild
 # To build all
-dotnet run -p tool -- --task build
+dotnet run --project tool -- --task build
 ```
 
 ## Test
@@ -84,9 +84,9 @@ _The 2nd step is to test built binaries to ensure the correctness of their imple
 ```bash
 cd bench
 # To test a subset
-dotnet run -p tool -- --task test --langs lisp go --problems nbody helloworld
+dotnet run --project tool -- --task test --langs lisp go --problems nbody helloworld
 # To test all
-dotnet run -p tool -- --task test
+dotnet run --project tool -- --task test
 ```
 
 ## Bench
@@ -96,16 +96,16 @@ _The 3rd step is to generate benchmarks_
 ```bash
 cd bench
 # To bench a subset
-dotnet run -p tool -- --task bench --langs lisp go --problems nbody helloworld
+dotnet run --project tool -- --task bench --langs lisp go --problems nbody helloworld
 # To bench all
-dotnet run -p tool -- --task bench
+dotnet run --project tool -- --task bench
 ```
 
 _For usage_
 
 ```bash
 cd bench
-dotnet run -p tool -- -h
+dotnet run --project tool -- -h
 
 BenchTool
   Main function

bench/algorithm/fasta/1.d

@@ -1,7 +1,4 @@
-// translation from zig version. From https://github.com/cyrusmsk/lang_benchmark
-
 import std;
-import std.outbuffer: OutBuffer;
 
 immutable maxLine = 60;
 immutable im = 139_968;
@@ -11,29 +8,28 @@ immutable ic = 29_573;
 uint seed = 42;
 
 static struct AminoAcid {
-    char l;
+    ubyte l;
     double p;
 }
 
 double nextRandom(double max) {
     seed = (seed * ia + ic) % im;
-    return max * seed/im;
+    return max * seed / im;
 }
 
-void repeatAndWrap (OutBuffer b, immutable char[] seq, size_t count) {
+void repeatAndWrap (immutable ubyte[] seq, size_t count) {
     uint len = cast(uint) seq.length;
-    char[] paddedSeq = new char[](len + maxLine);
+    ubyte[] paddedSeq = new ubyte[](len + maxLine);
     foreach (i, ref e; paddedSeq)
         e = seq[i % len];
 
     size_t off, idx;
+    size_t rem, lineLength;
     while (idx < count) {
-        immutable rem = count - idx;
-        immutable size_t lineLength = min(maxLine, rem);
+        rem = count - idx;
+        lineLength = min(maxLine, rem);
 
-        // speed up the writeln with lockWriter
-        b.write(paddedSeq[off .. off + lineLength]);
-        b.write("\n");
+        writeln(cast(string)paddedSeq[off .. off + lineLength]);
 
         off += lineLength;
         if (off > len)
@@ -42,20 +38,20 @@ void repeatAndWrap (OutBuffer b, immutable char[] seq, size_t count) {
     }
 }
 
-void generateAndWrap (OutBuffer b, immutable AminoAcid[] nucleotides, size_t count) {
+void generateAndWrap (immutable AminoAcid[] nucleotides, size_t count) {
     double cumProb = 0.0;
     double[] cumProbTotal = new double[](nucleotides.length);
     foreach(i, e; nucleotides) {
         cumProb += e.p;
         cumProbTotal[i] = cumProb * im;
     }
 
-    char[] line = new char[](maxLine+1);
-    line[maxLine] = '\n';
-    size_t idx;
+    ubyte[maxLine+1] line; // was new before
+    line[maxLine] = cast(ubyte)'\n';
+    size_t idx, rem, lineLength;
     while (idx < count) {
-        immutable rem = count - idx;
-        immutable size_t lineLength = min(maxLine, rem);
+        rem = count - idx;
+        lineLength = min(maxLine, rem);
         foreach (ref col; line[0 .. lineLength]) {
             immutable r = nextRandom(im);
             size_t c;
@@ -65,21 +61,18 @@ void generateAndWrap (OutBuffer b, immutable AminoAcid[] nucleotides, size_t cou
             col = nucleotides[c].l;
         }
         line[lineLength] = '\n';
-        b.write(line[0 .. lineLength + 1]);
+        write(cast(string)line[0 .. lineLength + 1]);
 
         idx += lineLength;
     }
 }
 
 void main(string[] args) {
     immutable uint n = args.length > 1 ? args[1].to!uint : 100;
-    OutBuffer b = new OutBuffer();
 
-    static immutable char[72*3 + 71] homoSapiensAlu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
-    write(">ONE Homo sapiens alu\n");
-    repeatAndWrap(b, homoSapiensAlu, 2 * n);
-    write(b);
-    b.clear();
+    static immutable(ubyte[72*3 + 71]) homoSapiensAlu = cast(immutable(ubyte[287]))"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+    writeln(">ONE Homo sapiens alu");
+    repeatAndWrap(homoSapiensAlu, 2 * n);
 
     static immutable AminoAcid[15] iubNucleotideInfo = [
         { l:'a', p: 0.27 },
@@ -98,18 +91,15 @@ void main(string[] args) {
         { l:'W', p: 0.02 },
         { l:'Y', p: 0.02 },
     ];
-    write(">TWO IUB ambiguity codes\n");
-    generateAndWrap(b, iubNucleotideInfo, 3 * n);
-    write(b);
-    b.clear();
+    writeln(">TWO IUB ambiguity codes");
+    generateAndWrap(iubNucleotideInfo, 3 * n);
 
     static immutable AminoAcid[4] homoSapienNucleotideInfo = [
         { l:'a', p: 0.3029549426680 },
         { l:'c', p: 0.1979883004921 },
         { l:'g', p: 0.1975473066391 },
         { l:'t', p: 0.3015094502008 },
     ];
-    write(">THREE Homo sapiens frequency\n");
-    generateAndWrap(b, homoSapienNucleotideInfo, 5 * n);
-    write(b);
+    writeln(">THREE Homo sapiens frequency");
+    generateAndWrap(homoSapienNucleotideInfo, 5 * n);
 }

bench/algorithm/fasta/6.rs

@@ -0,0 +1,167 @@
+// Ported from 1.zig
+
+use std::io::{self, BufWriter, StdoutLock, Write};
+
+const MAX_LINE_LENGTH: usize = 60;
+const IM: u32 = 139968;
+const IA: u32 = 3877;
+const IC: u32 = 29573;
+
+struct AminoAcid {
+    l: u8,
+    p: f64,
+}
+
+struct Random {
+    seed: u32,
+}
+
+impl Random {
+    fn new() -> Self {
+        Self { seed: 42 }
+    }
+
+    fn next(&mut self) -> f64 {
+        self.seed = (self.seed * IA + IC) % IM;
+        (IM as f64 * self.seed as f64) / IM as f64
+    }
+}
+
+impl Iterator for Random {
+    type Item = f64;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.next())
+    }
+}
+
+fn repeat_and_wrap(
+    out: &mut BufWriter<StdoutLock<'static>>,
+    sequence: &[u8],
+    count: usize,
+) -> io::Result<()> {
+    let n = sequence.len();
+    let padded_sequence = (0..(n + MAX_LINE_LENGTH))
+        .map(|i| sequence[i % n])
+        .collect::<Vec<_>>();
+
+    let mut off = 0;
+    let mut idx = 0;
+    while idx < count {
+        let rem = count - idx;
+        let line_length = MAX_LINE_LENGTH.min(rem);
+        out.write_all(&padded_sequence[off..off + line_length])?;
+        out.write_all(&[b'\n'])?;
+
+        off += line_length;
+        if off > n {
+            off -= n;
+        }
+        idx += line_length;
+    }
+    Ok(())
+}
+
+fn generate_and_wrap(
+    random: &mut Random,
+    out: &mut BufWriter<StdoutLock<'static>>,
+    nucleotides: &[AminoAcid],
+    count: usize,
+) -> io::Result<()> {
+    let mut cum_prob = 0.0;
+    let cum_prob_total = nucleotides
+        .iter()
+        .map(|&AminoAcid { l: _, p }| {
+            cum_prob += p;
+            cum_prob * IM as f64
+        })
+        .collect::<Vec<_>>();
+
+    let mut line = [0u8; MAX_LINE_LENGTH + 1];
+    line[MAX_LINE_LENGTH] = b'\n';
+
+    let mut idx = 0;
+    while idx < count {
+        let rem = count - idx;
+        let line_length = MAX_LINE_LENGTH.min(rem);
+
+        line[..line_length]
+            .iter_mut()
+            .zip(&mut *random)
+            .for_each(|(col, r)| {
+                let c = cum_prob_total
+                    .iter()
+                    .fold(0, |acc, &n| acc + (n <= r) as usize);
+
+                *col = nucleotides[c].l;
+            });
+
+        line[line_length] = b'\n';
+        out.write_all(&line[..line_length + 1])?;
+        idx += line_length;
+    }
+    Ok(())
+}
+
+pub fn main() -> io::Result<()> {
+    let stdout = io::stdout();
+    let mut stdout = io::BufWriter::new(stdout.lock());
+    let n = std::env::args_os()
+        .nth(1)
+        .and_then(|s| s.as_os_str().to_str().and_then(|s| s.parse().ok()))
+        .unwrap_or(1000);
+
+    let homo_sapiens_alu =
+        b"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC\
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG\
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG\
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+
+    stdout.write_all(b">ONE Homo sapiens alu\n".as_slice())?;
+    repeat_and_wrap(&mut stdout, &homo_sapiens_alu[..], 2 * n)?;
+    let mut random = Random::new();
+
+    let iub_nucleotide_info = &[
+        AminoAcid { l: b'a', p: 0.27 },
+        AminoAcid { l: b'c', p: 0.12 },
+        AminoAcid { l: b'g', p: 0.12 },
+        AminoAcid { l: b't', p: 0.27 },
+        AminoAcid { l: b'B', p: 0.02 },
+        AminoAcid { l: b'D', p: 0.02 },
+        AminoAcid { l: b'H', p: 0.02 },
+        AminoAcid { l: b'K', p: 0.02 },
+        AminoAcid { l: b'M', p: 0.02 },
+        AminoAcid { l: b'N', p: 0.02 },
+        AminoAcid { l: b'R', p: 0.02 },
+        AminoAcid { l: b'S', p: 0.02 },
+        AminoAcid { l: b'V', p: 0.02 },
+        AminoAcid { l: b'W', p: 0.02 },
+        AminoAcid { l: b'Y', p: 0.02 },
+    ];
+
+    stdout.write_all(b">TWO IUB ambiguity codes\n".as_slice())?;
+    generate_and_wrap(&mut random, &mut stdout, iub_nucleotide_info, 3 * n)?;
+
+    let homo_sapien_nucleotide_info = &[
+        AminoAcid {
+            l: b'a',
+            p: 0.3029549426680,
+        },
+        AminoAcid {
+            l: b'c',
+            p: 0.1979883004921,
+        },
+        AminoAcid {
+            l: b'g',
+            p: 0.1975473066391,
+        },
+        AminoAcid {
+            l: b't',
+            p: 0.3015094502008,
+        },
+    ];
+
+    stdout.write_all(b">THREE Homo sapiens frequency\n".as_slice())?;
+    generate_and_wrap(&mut random, &mut stdout, homo_sapien_nucleotide_info, 5 * n)?;
+    Ok(())
+}