Make Perlin benches use core functions

Also make Vectors pub to use in benches

benches/perlin.rs

@@ -3,7 +3,11 @@ extern crate criterion;
 extern crate noise;
 
 use criterion::{black_box, Criterion};
-use noise::{NoiseFn, Perlin};
+use noise::{
+    core::perlin::{perlin_2d, perlin_3d, perlin_4d},
+    permutationtable::PermutationTable,
+    Vector2, Vector3, Vector4,
+};
 
 criterion_group!(perlin, bench_perlin2, bench_perlin3, bench_perlin4);
 criterion_group!(
@@ -15,59 +19,70 @@ criterion_group!(
 criterion_main!(perlin, perlin_64x64);
 
 fn bench_perlin2(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 2d", |b| {
-        b.iter(|| perlin.get(black_box([42.0_f64, 37.0])))
+        b.iter(|| black_box(perlin_2d(Vector2::new(42.0_f64, 37.0), &hasher)))
     });
 }
 
 fn bench_perlin3(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 3d", |b| {
-        b.iter(|| perlin.get(black_box([42.0_f64, 37.0, 26.0])))
+        b.iter(|| black_box(perlin_3d(Vector3::new(42.0_f64, 37.0, 26.0), &hasher)))
     });
 }
 
 fn bench_perlin4(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 4d", |b| {
-        b.iter(|| perlin.get(black_box([42.0_f64, 37.0, 26.0, 128.0])))
+        b.iter(|| {
+            black_box(perlin_4d(
+                Vector4::new(42.0_f64, 37.0, 26.0, 128.0),
+                &hasher,
+            ))
+        })
     });
 }
 
 fn bench_perlin2_64x64(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 2d (64x64)", |b| {
         b.iter(|| {
             for y in 0i8..64 {
                 for x in 0i8..64 {
-                    black_box(perlin.get([x as f64, y as f64]));
+                    black_box(perlin_2d(Vector2::new(x as f64, y as f64), &hasher));
                 }
             }
         })
     });
 }
 
 fn bench_perlin3_64x64(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 3d (64x64)", |b| {
         b.iter(|| {
             for y in 0i8..64 {
                 for x in 0i8..64 {
-                    black_box(perlin.get([x as f64, y as f64, x as f64]));
+                    black_box(perlin_3d(
+                        Vector3::new(x as f64, y as f64, x as f64),
+                        &hasher,
+                    ));
                 }
             }
         })
     });
 }
 
 fn bench_perlin4_64x64(c: &mut Criterion) {
-    let perlin = Perlin::default();
+    let hasher = PermutationTable::new(0);
     c.bench_function("perlin 4d (64x64)", |b| {
         b.iter(|| {
             for y in 0i8..64 {
                 for x in 0i8..64 {
-                    black_box(perlin.get([x as f64, y as f64, x as f64, y as f64]));
+                    black_box(perlin_4d(
+                        Vector4::new(x as f64, y as f64, x as f64, y as f64),
+                        &hasher,
+                    ));
                 }
             }
         })

src/lib.rs

@@ -15,11 +15,12 @@
 #[macro_use]
 extern crate alloc;
 
+pub use crate::math::vectors::*;
 pub use crate::noise_fns::*;
 
 pub mod core;
 mod gradient;
-mod math;
+pub mod math;
 mod noise_fns;
 pub mod permutationtable;
 pub mod utils;

src/math.rs

@@ -3,7 +3,7 @@
 
 pub(crate) mod interpolate;
 pub(crate) mod s_curve;
-pub(crate) mod vectors;
+pub mod vectors;
 
 #[cfg(not(target_os = "emscripten"))]
 #[inline]