Release v0.2.1

Author: akubera

.circleci/config.yml

@@ -0,0 +1,98 @@
+version: 2.1
+orbs:
+#   codecov: codecov/[email protected]
+  rust: circleci/[email protected]
+
+jobs:
+  build-and-test:
+    parameters:
+      rust-version:
+        type: string
+      debian-version:
+        type: string
+        default: "buster"
+    docker:
+      - image: rust:<< parameters.rust-version >>-<< parameters.debian-version >>
+    environment:
+      RUSTFLAGS: '-D warnings'
+    steps:
+      - checkout
+      - run:
+          name: Rust Version
+          command: rustc --version; cargo --version
+      - restore_cache:
+          keys:
+            - bigdecimal-cargo-<< parameters.rust-version >>-{{ checksum "Cargo.toml" }}
+            - bigdecimal-cargo-
+      - run:
+          name: Check
+          command: cargo check
+      - save_cache:
+          paths:
+            - /usr/local/cargo
+          key: bigdecimal-cargo-<< parameters.rust-version >>-{{ checksum "Cargo.toml" }}
+      - run:
+          name: Build
+          command: cargo build
+      - run:
+          name: Test
+          command: cargo test
+
+  upload-coverage:
+    parameters:
+      rust-version:
+        type: string
+      debian-version:
+        type: string
+        default: "buster"
+    machine: true
+    steps:
+      - checkout
+      - run:
+          name: Generate Coverage
+          command: >
+              docker run
+              --security-opt seccomp=unconfined
+              -v "${PWD}:/home"
+              -e CI=true
+              $(bash <(curl -s https://codecov.io/env))
+              akubera/rust-codecov:<< parameters.rust-version >>-<< parameters.debian-version >>
+              sh -c 'cargo test -q && kcov-rust && upload-kcov-results-to-codecov'
+      - store_artifacts:
+          path: target/cov
+      - store_test_results:
+          path: target/cov
+
+  lint-check:
+    docker:
+      - image: cimg/rust:1.54.0
+    steps:
+      - checkout
+      - rust/build
+      - rust/format
+      - rust/clippy
+      - rust/test
+      - run:
+          name: Build examples
+          command: cargo build --examples
+
+workflows:
+  version: 2
+  build-and-test:
+    jobs:
+    - build-and-test:
+        name: build-and-test-1.34.0
+        rust-version: "1.34.0"
+        debian-version: "stretch"
+    - build-and-test:
+        matrix:
+          parameters:
+            rust-version:
+            - "1.40.0"
+            - "1.50.0"
+            - "1.54.0"
+    - upload-coverage:
+        rust-version: "1.54.0"
+        requires:
+          - build-and-test-1.54.0
+    - lint-check

.gitignore

@@ -3,3 +3,4 @@ target
 
 .vscode/
 
+.*cache/

.rustfmt.toml

@@ -0,0 +1,3 @@
+
+reorder_imports = false
+max_width = 120

.travis.yml

@@ -1,6 +1,6 @@
 [package]
 name = "bigdecimal"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Andrew Kubera"]
 description = "Arbitrary precision decimal numbers"
 documentation = "https://docs.rs/bigdecimal"
@@ -10,8 +10,8 @@ keywords = ["mathematics", "numerics", "decimal", "arbitrary-precision", "floati
 license = "MIT/Apache-2.0"
 
 [dependencies]
-num-bigint = "0.3"
-num-integer = "0.1.43"
+num-bigint = "0.4"
+num-integer = "0.1"
 num-traits = "0.2"
 serde = { version = "1.0", optional = true }
 

Cargo.toml

@@ -1,23 +1,23 @@
-
 extern crate bigdecimal;
 
 use bigdecimal::BigDecimal;
 use std::time::Instant;
 use std::str::FromStr;
 
-fn main()
-{
-  //   let mut x = BigDecimal::from(1.1);
+fn main() {
+    //   let mut x = BigDecimal::from(1.1);
     let mut x = BigDecimal::from_str("1.1").unwrap();
     // for iter in 0..1_000_000 {
-    for iter in 0..1_000 {
+    for iter in 0..26 {
         let start = Instant::now();
         x = x.clone() * x;
         // x = x.take_and_square();
         let end = Instant::now();
         let usage = end - start;
-        println!("iter {} takes {} secs", iter, usage.as_secs() as f32 + usage.subsec_nanos() as f32 / 1.0e9);
+        println!(
+            "iter {} takes {} secs",
+            iter,
+            usage.as_secs() as f32 + usage.subsec_nanos() as f32 / 1.0e9
+        );
     }
 }
-
-

examples/repeated_squares.rs

@@ -0,0 +1,80 @@
+extern crate bigdecimal;
+use bigdecimal::*;
+use std::str::FromStr;
+
+/* Default example output:
+
+Hello, Big Decimals!
+Input (0.8) with 10 decimals: 0.8 vs 0.8)
+square 0.64
+From Prim: 3.300000000000000
+match test 33.90000000000000
+24.00000000000000 + 34.00000000000000 = 58.00000000000000
+sum mut: 48.00000000000000
+0.000000000000000 IS equal to zero
+24.00000000000000 / 1.000000000000000 = 24.00000000000000
+24.0 / 1.000000000000000 = 24.0
+24.0 / 1.5 = 16
+24.000 / 1.50 = 16.0
+*/
+
+fn main() {
+    println!("Hello, Big Decimals!");
+    let input = "0.8";
+    let dec = BigDecimal::from_str(&input).unwrap();
+    let float = f32::from_str(&input).unwrap();
+    println!("Input ({}) with 10 decimals: {} vs {})", input, dec, float);
+
+    let bd_square = dec.square();
+    println!("square {}", bd_square);
+
+    let bd_from_prim = BigDecimal::from_f64(3.3);
+    println!("From Prim: {}", bd_from_prim.unwrap());
+
+    let bd_match: BigDecimal = match BigDecimal::from_f64(33.9) {
+        Some(bd) => bd,
+        None => BigDecimal::zero(),
+    };
+    println!("match test {}", bd_match);
+
+    let bd_add1 = &BigDecimal::from_f64(24.0).unwrap();
+    let bd_add2 = &BigDecimal::from_f64(34.0).unwrap();
+    print_sum(bd_add1, bd_add2);
+
+    let mut bd_add3 = BigDecimal::from_f64(24.0).unwrap();
+    let bd_add4 = BigDecimal::from_f64(24.0).unwrap();
+    bd_add3 += bd_add4;
+    println!("sum mut: {}", bd_add3);
+
+    let bd_nez = BigDecimal::from_f64(0.0).unwrap();
+    if bd_nez != BigDecimal::zero() {
+        println!("{} is not equal to zero", &bd_nez);
+    } else {
+        println!("{} IS equal to zero", &bd_nez);
+    }
+
+    let bd_div1 = &BigDecimal::from_f64(24.0).unwrap();
+    let bd_div2 = &BigDecimal::from_f64(1.0).unwrap();
+    print_division(bd_div1, bd_div2);
+
+    let bd_div1 = &BigDecimal::from_str("24.0").unwrap();
+    print_division(bd_div1, bd_div2);
+
+    let bd_num = &BigDecimal::from_str("24.0").unwrap();
+    let bd_den = &BigDecimal::from_str("1.5").unwrap();
+    print_division(bd_num, bd_den);
+
+    let bd_num = &BigDecimal::from_str("24.000").unwrap();
+    let bd_den = &BigDecimal::from_str("1.50").unwrap();
+    print_division(bd_num, bd_den);
+}
+
+fn print_sum(a: &BigDecimal, b: &BigDecimal) {
+    let sum = a + b;
+    println!("{} + {} = {}", a, b, sum);
+}
+
+fn print_division(num: &BigDecimal, den: &BigDecimal) {
+    let quotient = num / den;
+    println!("{} / {} = {}", num, den, quotient);
+}