Giter VIP home page Giter VIP logo

rand_mt's Introduction

Artichoke Ruby

GitHub Actions Discord Twitter
Crate API API trunk

Artichoke Ruby logo

Artichoke is a Ruby implementation written in Rust and Ruby. Artichoke intends to be MRI-compatible and targets recent MRI Ruby. Artichoke provides a Ruby runtime implemented in Rust and Ruby.

Try Artichoke

Artichoke Ruby WebAssembly playground
Artichoke Ruby Wasm Playground

You can try Artichoke in your browser. The Artichoke Playground runs a WebAssembly build of Artichoke.

Install Artichoke

Prebuilt nightly binaries

Download a prebuilt binary from artichoke/nightly. Binaries are available for Linux, Linux/musl, macOS, and Windows.

These daily binaries track the latest trunk branch of Artichoke.

Binaries are also distributed through ruby-build. To install with rbenv:

$ rbenv install artichoke-dev

Cargo

You can install a pre-release build of Artichoke using cargo, Rust's package manager, by running:

$ cargo install --git https://github.com/artichoke/artichoke --branch trunk --locked artichoke

To install via cargo install or to checkout and build locally, you'll need Rust and clang. BUILD.md has more detail on how to set up the compiler toolchain.

Docker

Artichoke is available on Docker Hub.

You can launch a REPL by running:

docker run -it docker.io/artichokeruby/artichoke airb

Usage

Artichoke ships with two binaries: airb and artichoke.

airb

airb is the Artichoke implementation of irb and is an interactive Ruby shell and REPL.

airb is a readline-enabled shell, although it does not persist history.

artichoke

artichoke is the ruby binary frontend to Artichoke.

artichoke supports executing programs via files, stdin, or inline with one or more -e flags.

Artichoke can require, require_relative, and load files from the local file system, but otherwise does not yet support local file system access. A temporary workaround is to inject data into the interpreter with the --with-fixture flag, which reads file contents into a $fixture global.

$ artichoke --help
Artichoke is a Ruby made with Rust.

Usage: artichoke [OPTIONS] [programfile] [arguments]...

Arguments:
  [programfile]
  [arguments]...

Options:
      --copyright               print the copyright
  -e <commands>                 one line of script. Several -e's allowed. Omit [programfile]
      --with-fixture <fixture>  file whose contents will be read into the `$fixture` global
  -h, --help                    Print help
  -V, --version                 Print version

Design and Goals

Artichoke is designed to enable experimentation. The top goals of the project are:

Contributing

Artichoke aspires to be an MRI Ruby-compatible implementation of the Ruby programming language. There is lots to do.

If Artichoke does not run Ruby source code in the same way that MRI does, it is a bug and we would appreciate if you filed an issue so we can fix it.

If you would like to contribute code 👩‍💻👨‍💻, find an issue that looks interesting and leave a comment that you're beginning to investigate. If there is no issue, please file one before beginning to work on a PR. Good first issues are labeled E-easy.

Discussion

If you'd like to engage in a discussion outside of GitHub, you can join Artichoke's public Discord server.

License

artichoke is licensed with the MIT License (c) Ryan Lopopolo.

Some portions of Artichoke are derived from third party sources. The READMEs in each workspace crate discuss which third party licenses are applicable to the sources and derived works in Artichoke.

rand_mt's People

Contributors

artichoke-ci avatar briankung avatar dcrewi avatar dependabot-preview[bot] avatar dependabot[bot] avatar enet4 avatar lopopolo avatar sacundim avatar

Stargazers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Watchers

avatar avatar avatar avatar

Forkers

briankung ignassew nneesshh shabbirhasan1

rand_mt's Issues

Naming convention

Not really an issue, just a suggestion (Or a bikeshedding, sorry).
Mt19937GenRand32 and Mt19937GenRand64 are too long, I agree. But Mt and Mt64 are somewhat non-conventional. Maybe it would be better to pick names like Mt19937b32 and Mt19937b64?

Replace hand-rolled chunks loop in `fill_bytes` with `chunks_exact_mut`

Both Mt::fill_bytes and Mt64::fill_bytes use a handrolled implementation of [u8]::chunks_exact_mut.

Replace these while loops with use of the ChunksExactMut iterator.

rand_mt/src/mt.rs

Lines 306 to 317 in 7123536

let mut left = dest;
while left.len() >= CHUNK {
let (next, remainder) = left.split_at_mut(CHUNK);
left = remainder;
let chunk: [u8; CHUNK] = self.next_u32().to_le_bytes();
next.copy_from_slice(&chunk);
}
let n = left.len();
if n > 0 {
let chunk: [u8; CHUNK] = self.next_u32().to_le_bytes();
left.copy_from_slice(&chunk[..n]);
}

rand_mt/src/mt64.rs

Lines 289 to 300 in 7123536

let mut left = dest;
while left.len() >= CHUNK {
let (next, remainder) = left.split_at_mut(CHUNK);
left = remainder;
let chunk: [u8; CHUNK] = self.next_u64().to_le_bytes();
next.copy_from_slice(&chunk);
}
let n = left.len();
if n > 0 {
let chunk: [u8; CHUNK] = self.next_u64().to_le_bytes();
left.copy_from_slice(&chunk[..n]);
}

Consider supporting CPython's random compatibility

In order to support CPython there are only a couple small changes required. I would like to suggest a MtPython struct that would generate values according to the CPython source code.

I am willing to write the code myself and submit a PR.

If you think that this doesn't suit your library, please consider at least adding this information to the README or the documentation.

Rust reference implementation:

use rand_mt::Mt;

const SEED: u32 = 2137;

fn main() {
    // Every python seed is converted, and initialized as a key: https://github.com/python/cpython/blob/ce558e69d4087dd3653207de78345fbb8a2c7835/Modules/_randommodule.c#LL355C8-L355C8
    let mut rng = Mt::new_with_key([SEED]);

    // CPython does this to get 64 bit float: https://github.com/python/cpython/blob/ce558e69d4087dd3653207de78345fbb8a2c7835/Modules/_randommodule.c#L181
    let a = rng.next_u32() >> 5;
    let b = rng.next_u32() >> 6;
    let n_rust = (a as f64 * 67108864.0 + b as f64) * (1.0 / 9007199254740992.0);

    // Python:
    // #!/bin/python3
    // import random
    //
    // SEED = 2137
    //
    // random.seed(SEED)
    // n_python = random.random()
    // assert n_python == 0.571786152497536
    let n_python = 0.571786152497536;

    assert_eq!(n_rust, n_python);
}

CPython random seed using bytearray: https://github.com/python/cpython/blob/ce558e69d4087dd3653207de78345fbb8a2c7835/Modules/_randommodule.c#LL355C8-L355C8
CPython random.random() implementation: https://github.com/python/cpython/blob/ce558e69d4087dd3653207de78345fbb8a2c7835/Modules/_randommodule.c#L181

Related to #192

Random number generated

I have a code in python that uses the random.py file Random class. In python when generating numbers with the Random class and seed 123 I receive a number 261662301160200998434711212977610535782, but when I try to reproduce the same in Rust it gives me this result 258431468044781239883754362733579478088.
Code example:

let mut rng = mt::MT19937::MT19937::from_seed(123i32.to_le_bytes());
let mut bytes:[u8;16] = [0;16]; 
let res:u128 = rng.gen();

Can you help solve this issue

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.