ci: update version string in docs

.github/workflows/pypi-gpu.yml

@@ -34,7 +34,6 @@ jobs:
         run: |
             mv pyproject.toml pyproject.toml.orig
             sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig >pyproject.toml
-            sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
 
       - uses: actions-rs/toolchain@v1
         with:

.github/workflows/pypi.yml

@@ -233,14 +233,6 @@ jobs:
           python-version: 3.12
           architecture: x64
 
-      - name: Set pyproject.toml version to match github tag
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          mv pyproject.toml pyproject.toml.orig
-          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
-
       - name: Set Cargo.toml version to match github tag
         shell: bash
         env:
@@ -250,6 +242,7 @@ jobs:
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.orig >Cargo.toml
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
+
       - name: Install required libraries
         shell: bash
         run: |

.github/workflows/swift-pm.yml

@@ -1,129 +0,0 @@
-name: Build and Publish EZKL iOS SPM package
-
-on:
-  push:
-    tags:
-      # Only support SemVer versioning tags
-      - 'v[0-9]+.[0-9]+.[0-9]+'
-      - '[0-9]+.[0-9]+.[0-9]+'
-
-jobs:
-  build-and-update:
-    runs-on: macos-latest
-    env:
-      EZKL_SWIFT_PACKAGE_REPO: github.com/zkonduit/ezkl-swift-package.git
-
-    steps:
-      - name: Checkout EZKL
-        uses: actions/checkout@v3
-
-      - name: Extract TAG from github.ref_name
-        run: |
-          # github.ref_name is provided by GitHub Actions and contains the tag name directly.
-          TAG="${{ github.ref_name }}"
-          echo "Original TAG: $TAG"
-          # Remove leading 'v' if present to match the Swift Package Manager version format.
-          NEW_TAG=${TAG#v}
-          echo "Stripped TAG: $NEW_TAG"
-          echo "TAG=$NEW_TAG" >> $GITHUB_ENV
-
-      - name: Install Rust (nightly)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          override: true
-
-      - name: Build EzklCoreBindings
-        run: CONFIGURATION=release cargo run --bin ios_gen_bindings --features "ios-bindings uuid camino uniffi_bindgen" --no-default-features
-
-      - name: Clone ezkl-swift-package repository
-        run: |
-          git clone https://${{ env.EZKL_SWIFT_PACKAGE_REPO }}
-
-      - name: Copy EzklCoreBindings
-        run: |
-          rm -rf ezkl-swift-package/Sources/EzklCoreBindings
-          cp -r build/EzklCoreBindings ezkl-swift-package/Sources/
-
-      - name: Copy Test Files
-        run: |
-          rm -rf ezkl-swift-package/Tests/EzklAssets/*
-          cp tests/assets/kzg ezkl-swift-package/Tests/EzklAssets/kzg.srs
-          cp tests/assets/input.json ezkl-swift-package/Tests/EzklAssets/input.json
-          cp tests/assets/model.compiled ezkl-swift-package/Tests/EzklAssets/network.ezkl
-          cp tests/assets/settings.json ezkl-swift-package/Tests/EzklAssets/settings.json
-
-      - name: Check for changes
-        id: check_changes
-        run: |
-          cd ezkl-swift-package
-          if git diff --quiet Sources/EzklCoreBindings Tests/EzklAssets; then
-            echo "no_changes=true" >> $GITHUB_OUTPUT
-          else
-            echo "no_changes=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Set up Xcode environment
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
-          sudo xcodebuild -license accept
-
-      - name: Run Package Tests
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package
-          xcodebuild test \
-            -scheme EzklPackage \
-            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
-            -resultBundlePath ../testResults
-
-      - name: Run Example App Tests
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package/Example
-          xcodebuild test \
-            -project Example.xcodeproj \
-            -scheme EzklApp \
-            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
-            -parallel-testing-enabled NO \
-            -resultBundlePath ../../exampleTestResults \
-            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder
-
-      - name: Setup Git
-        run: |
-          cd ezkl-swift-package
-          git config user.name "GitHub Action"
-          git config user.email "action@github.com"
-          git remote set-url origin https://zkonduit:${EZKL_SWIFT_PACKAGE_REPO_TOKEN}@${{ env.EZKL_SWIFT_PACKAGE_REPO }}
-        env:
-          EZKL_SWIFT_PACKAGE_REPO_TOKEN: ${{ secrets.EZKL_PORTER_TOKEN }}
-
-      - name: Commit and Push Changes
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package
-          git add Sources/EzklCoreBindings Tests/EzklAssets
-          git commit -m "Automatically updated EzklCoreBindings for EZKL"
-          
-          if ! git push origin; then
-            echo "::error::Failed to push changes to ${{ env.EZKL_SWIFT_PACKAGE_REPO }}. Please ensure that EZKL_PORTER_TOKEN has the correct permissions."
-            exit 1
-          fi
-
-      - name: Tag the latest commit
-        run: |
-          cd ezkl-swift-package
-          source $GITHUB_ENV
-          
-          # Tag the latest commit on the current branch
-          if git rev-parse "$TAG" >/dev/null 2>&1; then
-            echo "Tag $TAG already exists locally. Skipping tag creation."
-          else
-            git tag "$TAG"
-          fi
-
-          if ! git push origin "$TAG"; then
-            echo "::error::Failed to push tag '$TAG' to ${{ env.EZKL_SWIFT_PACKAGE_REPO }}. Please ensure EZKL_PORTER_TOKEN has correct permissions."
-            exit 1
-          fi

.github/workflows/update-ios-package.yml

@@ -0,0 +1,85 @@
+name: Build and Publish EZKL iOS SPM package
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "The tag to release"
+        required: true
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build-and-update:
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout EZKL
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+
+      - name: Build EzklCoreBindings
+        run: CONFIGURATION=release cargo run --bin ios_gen_bindings --features "ios-bindings uuid camino uniffi_bindgen" --no-default-features
+
+      - name: Clone ezkl-swift-package repository
+        run: |
+          git clone https://github.com/zkonduit/ezkl-swift-package.git
+
+      - name: Copy EzklCoreBindings
+        run: |
+          rm -rf ezkl-swift-package/Sources/EzklCoreBindings
+          cp -r build/EzklCoreBindings ezkl-swift-package/Sources/
+
+      - name: Copy Test Files
+        run: |
+          rm -rf ezkl-swift-package/Tests/EzklAssets/*
+          
+          cp tests/assets/kzg ezkl-swift-package/Tests/EzklAssets/kzg.srs
+          cp tests/assets/input.json ezkl-swift-package/Tests/EzklAssets/input.json
+          cp tests/assets/model.compiled ezkl-swift-package/Tests/EzklAssets/network.ezkl
+          cp tests/assets/settings.json ezkl-swift-package/Tests/EzklAssets/settings.json
+
+      - name: Set up Xcode environment
+        run: |
+          sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
+          sudo xcodebuild -license accept
+
+      - name: Run Package Tests
+        run: |
+          cd ezkl-swift-package
+          xcodebuild test \
+            -scheme EzklPackage \
+            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+            -resultBundlePath ../testResults
+
+      - name: Run Example App Tests
+        run: |
+          cd ezkl-swift-package/Example
+          xcodebuild test \
+            -project Example.xcodeproj \
+            -scheme EzklApp \
+            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+            -parallel-testing-enabled NO \
+            -resultBundlePath ../../exampleTestResults \
+            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder
+
+      - name: Commit and Push Changes to feat/ezkl-direct-integration
+        run: |
+          cd ezkl-swift-package
+          git config user.name "GitHub Action"
+          git config user.email "action@github.com"
+          git add Sources/EzklCoreBindings
+          git add Tests/EzklAssets
+          git commit -m "Automatically updated EzklCoreBindings for EZKL"
+          git tag ${{ github.event.inputs.tag }}
+          git remote set-url origin https://zkonduit:${EZKL_PORTER_TOKEN}@github.com/zkonduit/ezkl-swift-package.git
+          git push origin
+          git push origin tag ${{ github.event.inputs.tag }}
+        env:
+          EZKL_PORTER_TOKEN: ${{ secrets.EZKL_PORTER_TOKEN }}

Cargo.toml

@@ -147,10 +147,6 @@ shellexpand = "3.1.0"
 runner = 'wasm-bindgen-test-runner'
 
 
-[[bench]]
-name = "zero_finder"
-harness = false
-
 [[bench]]
 name = "accum_dot"
 harness = false
@@ -290,11 +286,3 @@ rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1
 # panic = "abort"
-
-
-[package.metadata.wasm-pack.profile.release]
-wasm-opt = [
-    "-O4",
-    "--flexible-inline-max-function-size",
-    "4294967295",
-]

benches/zero_finder.rs

@@ -1,116 +0,0 @@
-use std::thread;
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use halo2curves::{bn256::Fr as F, ff::Field};
-use maybe_rayon::{
-    iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator},
-    slice::ParallelSlice,
-};
-use rand::Rng;
-
-// Assuming these are your types
-#[derive(Clone)]
-enum ValType {
-    Constant(F),
-    AssignedConstant(usize, F),
-    Other,
-}
-
-// Helper to generate test data
-fn generate_test_data(size: usize, zero_probability: f64) -> Vec<ValType> {
-    let mut rng = rand::thread_rng();
-    (0..size)
-        .map(|_i| {
-            if rng.gen::<f64>() < zero_probability {
-                ValType::Constant(F::ZERO)
-            } else {
-                ValType::Constant(F::ONE) // Or some other non-zero value
-            }
-        })
-        .collect()
-}
-
-fn bench_zero_finding(c: &mut Criterion) {
-    let sizes = [
-        1_000,         // 1K
-        10_000,        // 10K
-        100_000,       // 100K
-        256 * 256 * 2, // Our specific case
-        1_000_000,     // 1M
-        10_000_000,    // 10M
-    ];
-
-    let zero_probability = 0.1; // 10% zeros
-
-    let mut group = c.benchmark_group("zero_finding");
-    group.sample_size(10); // Adjust based on your needs
-
-    for &size in &sizes {
-        let data = generate_test_data(size, zero_probability);
-
-        // Benchmark sequential version
-        group.bench_function(format!("sequential_{}", size), |b| {
-            b.iter(|| {
-                let result = data
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(i, e)| match e {
-                        ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                            (*r == F::ZERO).then_some(i)
-                        }
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>();
-                black_box(result)
-            })
-        });
-
-        // Benchmark parallel version
-        group.bench_function(format!("parallel_{}", size), |b| {
-            b.iter(|| {
-                let result = data
-                    .par_iter()
-                    .enumerate()
-                    .filter_map(|(i, e)| match e {
-                        ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                            (*r == F::ZERO).then_some(i)
-                        }
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>();
-                black_box(result)
-            })
-        });
-
-        // Benchmark chunked parallel version
-        group.bench_function(format!("chunked_parallel_{}", size), |b| {
-            b.iter(|| {
-                let num_cores = thread::available_parallelism()
-                    .map(|n| n.get())
-                    .unwrap_or(1);
-                let chunk_size = (size / num_cores).max(100);
-
-                let result = data
-                    .par_chunks(chunk_size)
-                    .enumerate()
-                    .flat_map(|(chunk_idx, chunk)| {
-                        chunk
-                            .par_iter() // Make sure we use par_iter() here
-                            .enumerate()
-                            .filter_map(move |(i, e)| match e {
-                                ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                                    (*r == F::ZERO).then_some(chunk_idx * chunk_size + i)
-                                }
-                                _ => None,
-                            })
-                    })
-                    .collect::<Vec<_>>();
-                black_box(result)
-            })
-        });
-    }
-    group.finish();
-}
-
-criterion_group!(benches, bench_zero_finding);
-criterion_main!(benches);

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '16.2.6'
+release = '16.2.1'
 version = release
 
 

pyproject.toml

@@ -12,7 +12,6 @@ asyncio_mode = "auto"
 
 [project]
 name = "ezkl"
-version = "0.0.0"
 requires-python = ">=3.7"
 classifiers = [
     "Programming Language :: Rust",

src/bindings/universal.rs

@@ -141,11 +141,10 @@ pub(crate) fn gen_vk(
     .map_err(|e| EZKLError::InternalError(format!("Failed to create verifying key: {}", e)))?;
 
     let mut serialized_vk = Vec::new();
-    vk.write(
-        &mut serialized_vk,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
-    )
-    .map_err(|e| EZKLError::InternalError(format!("Failed to serialize verifying key: {}", e)))?;
+    vk.write(&mut serialized_vk, halo2_proofs::SerdeFormat::RawBytes)
+        .map_err(|e| {
+            EZKLError::InternalError(format!("Failed to serialize verifying key: {}", e))
+        })?;
 
     Ok(serialized_vk)
 }
@@ -166,7 +165,7 @@ pub(crate) fn gen_pk(
     let mut reader = BufReader::new(&vk[..]);
     let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         circuit.settings().clone(),
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize verifying key: {}", e)))?;
@@ -198,7 +197,7 @@ pub(crate) fn verify(
     let mut reader = BufReader::new(&vk[..]);
     let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         circuit_settings.clone(),
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize vk: {}", e)))?;
@@ -278,7 +277,7 @@ pub(crate) fn verify_aggr(
     let mut reader = BufReader::new(&vk[..]);
     let vk = VerifyingKey::<G1Affine>::read::<_, AggregationCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         (),
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize vk: {}", e)))?;
@@ -366,7 +365,7 @@ pub(crate) fn prove(
     let mut reader = BufReader::new(&pk[..]);
     let pk = ProvingKey::<G1Affine>::read::<_, GraphCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         circuit.settings().clone(),
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proving key: {}", e)))?;
@@ -488,7 +487,7 @@ pub(crate) fn vk_validation(vk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKL
     let mut reader = BufReader::new(&vk[..]);
     let _ = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         circuit_settings,
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize verifying key: {}", e)))?;
@@ -505,7 +504,7 @@ pub(crate) fn pk_validation(pk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKL
     let mut reader = BufReader::new(&pk[..]);
     let _ = ProvingKey::<G1Affine>::read::<_, GraphCircuit>(
         &mut reader,
-        halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        halo2_proofs::SerdeFormat::RawBytes,
         circuit_settings,
     )
     .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proving key: {}", e)))?;

src/eth.rs

@@ -488,8 +488,7 @@ pub async fn deploy_da_verifier_via_solidity(
         }
     }
 
-    
-    match call_to_account {
+    let contract = match call_to_account {
         Some(call) => {
             deploy_single_da_contract(
                 client,
@@ -515,7 +514,8 @@ pub async fn deploy_da_verifier_via_solidity(
             )
             .await
         }
-    }
+    };
+    return contract;
 }
 
 async fn deploy_multi_da_contract(
@@ -630,7 +630,7 @@ async fn deploy_single_da_contract(
             // bytes memory _callData,
             PackedSeqToken(call_data.as_ref()),
             // uint256 _decimals,
-            WordToken(B256::from(decimals)),
+            WordToken(B256::from(decimals).into()),
             // uint[] memory _scales,
             DynSeqToken(
                 scales

src/graph/utilities.rs

@@ -1136,21 +1136,23 @@ pub fn new_op_from_onnx(
                         a: crate::circuit::utils::F32(exponent),
                     })
                 }
-            } else if let Some(c) = inputs[0].opkind().get_mutable_constant() {
-                inputs[0].decrement_use();
-                deleted_indices.push(0);
-                if c.raw_values.len() > 1 {
-                    unimplemented!("only support scalar base")
-                }
-
-                let base = c.raw_values[0];
-
-                SupportedOp::Nonlinear(LookupOp::Exp {
-                    scale: scale_to_multiplier(input_scales[1]).into(),
-                    base: base.into(),
-                })
             } else {
-                unimplemented!("only support constant base or pow for now")
+                if let Some(c) = inputs[0].opkind().get_mutable_constant() {
+                    inputs[0].decrement_use();
+                    deleted_indices.push(0);
+                    if c.raw_values.len() > 1 {
+                        unimplemented!("only support scalar base")
+                    }
+
+                    let base = c.raw_values[0];
+
+                    SupportedOp::Nonlinear(LookupOp::Exp {
+                        scale: scale_to_multiplier(input_scales[1]).into(),
+                        base: base.into(),
+                    })
+                } else {
+                    unimplemented!("only support constant base or pow for now")
+                }
             }
         }
         "Div" => {

src/tensor/val.rs

@@ -1,12 +1,12 @@
 use crate::{circuit::region::ConstantsMap, fieldutils::felt_to_integer_rep};
-use maybe_rayon::slice::{Iter, ParallelSlice};
+use maybe_rayon::slice::Iter;
 
 use super::{
     ops::{intercalate_values, pad, resize},
     *,
 };
 use halo2_proofs::{arithmetic::Field, circuit::Cell, plonk::Instance};
-use maybe_rayon::iter::{FilterMap, ParallelIterator};
+use maybe_rayon::iter::{FilterMap, IntoParallelIterator, ParallelIterator};
 
 pub(crate) fn create_constant_tensor<
     F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + PartialOrd,
@@ -455,7 +455,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         }
     }
 
-    /// Returns an iterator over the [ValTensor]'s constants.
+    /// Returns the number of constants in the [ValTensor].
     pub fn create_constants_map_iterator(
         &self,
     ) -> FilterMap<Iter<'_, ValType<F>>, fn(&ValType<F>) -> Option<(F, ValType<F>)>> {
@@ -473,48 +473,20 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         }
     }
 
-    /// Returns a map of the constants in the [ValTensor].
+    /// Returns the number of constants in the [ValTensor].
     pub fn create_constants_map(&self) -> ConstantsMap<F> {
-        let threshold = 1_000_000; // Tuned using the benchmarks
-
-        if self.len() < threshold {
-            match self {
-                ValTensor::Value { inner, .. } => inner
-                    .par_iter()
-                    .filter_map(|x| {
-                        if let ValType::Constant(v) = x {
-                            Some((*v, x.clone()))
-                        } else {
-                            None
-                        }
-                    })
-                    .collect(),
-                ValTensor::Instance { .. } => ConstantsMap::new(),
-            }
-        } else {
-            // Use parallel for larger arrays
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match self {
-                ValTensor::Value { inner, .. } => inner
-                    .par_chunks(chunk_size)
-                    .flat_map(|chunk| {
-                        chunk
-                            .par_iter() // Make sure we use par_iter() here
-                            .filter_map(|x| {
-                                if let ValType::Constant(v) = x {
-                                    Some((*v, x.clone()))
-                                } else {
-                                    None
-                                }
-                            })
-                    })
-                    .collect(),
-                ValTensor::Instance { .. } => ConstantsMap::new(),
-            }
+        match self {
+            ValTensor::Value { inner, .. } => inner
+                .par_iter()
+                .filter_map(|x| {
+                    if let ValType::Constant(v) = x {
+                        Some((*v, x.clone()))
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            ValTensor::Instance { .. } => ConstantsMap::new(),
         }
     }
 
@@ -906,161 +878,70 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
 
     /// remove constant zero values constants
     pub fn remove_const_zero_values(&mut self) {
-        let size_threshold = 1_000_000; // Tuned using the benchmarks
-
-        if self.len() < size_threshold {
-            match self {
-                ValTensor::Value { inner: v, dims, .. } => {
-                    *v = v
-                        .clone()
-                        .into_iter()
-                        .filter_map(|e| {
-                            if let ValType::Constant(r) = e {
-                                if r == F::ZERO {
-                                    return None;
-                                }
-                            } else if let ValType::AssignedConstant(_, r) = e {
-                                if r == F::ZERO {
-                                    return None;
-                                }
+        match self {
+            ValTensor::Value { inner: v, dims, .. } => {
+                *v = v
+                    .clone()
+                    .into_par_iter()
+                    .filter_map(|e| {
+                        if let ValType::Constant(r) = e {
+                            if r == F::ZERO {
+                                return None;
                             }
-                            Some(e)
-                        })
-                        .collect();
-                    *dims = v.dims().to_vec();
-                }
-                ValTensor::Instance { .. } => {}
-            }
-        } else {
-            // Use parallel for larger arrays
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match self {
-                ValTensor::Value { inner: v, dims, .. } => {
-                    *v = v
-                        .par_chunks_mut(chunk_size)
-                        .flat_map(|chunk| {
-                            chunk
-                                .par_iter_mut() // Make sure we use par_iter() here
-                                .filter_map(|e| {
-                                    if let ValType::Constant(r) = e {
-                                        if *r == F::ZERO {
-                                            return None;
-                                        }
-                                    } else if let ValType::AssignedConstant(_, r) = e {
-                                        if *r == F::ZERO {
-                                            return None;
-                                        }
-                                    }
-                                    Some(e.clone())
-                                })
-                        })
-                        .collect();
-                    *dims = v.dims().to_vec();
-                }
-                ValTensor::Instance { .. } => {}
+                        } else if let ValType::AssignedConstant(_, r) = e {
+                            if r == F::ZERO {
+                                return None;
+                            }
+                        }
+                        Some(e)
+                    })
+                    .collect();
+                *dims = v.dims().to_vec();
             }
+            ValTensor::Instance { .. } => {}
         }
     }
 
-    /// filter constant zero values constants
+    /// gets constants
     pub fn get_const_zero_indices(&self) -> Vec<usize> {
-        let size_threshold = 1_000_000; // Tuned using the benchmarks
-
-        if self.len() < size_threshold {
-            // Use single-threaded for smaller arrays
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(i, e)| {
-                        match e {
-                            // Combine both match arms to reduce branching
-                            ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                                (*r == F::ZERO).then_some(i)
-                            }
-                            _ => None,
+        match self {
+            ValTensor::Value { inner: v, .. } => v
+                .par_iter()
+                .enumerate()
+                .filter_map(|(i, e)| {
+                    if let ValType::Constant(r) = e {
+                        if *r == F::ZERO {
+                            return Some(i);
                         }
-                    })
-                    .collect(),
-                ValTensor::Instance { .. } => vec![],
-            }
-        } else {
-            // Use parallel for larger arrays
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .par_chunks(chunk_size)
-                    .enumerate()
-                    .flat_map(|(chunk_idx, chunk)| {
-                        chunk
-                            .par_iter() // Make sure we use par_iter() here
-                            .enumerate()
-                            .filter_map(move |(i, e)| match e {
-                                ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                                    (*r == F::ZERO).then_some(chunk_idx * chunk_size + i)
-                                }
-                                _ => None,
-                            })
-                    })
-                    .collect::<Vec<_>>(),
-                ValTensor::Instance { .. } => vec![],
-            }
+                    } else if let ValType::AssignedConstant(_, r) = e {
+                        if *r == F::ZERO {
+                            return Some(i);
+                        }
+                    }
+                    None
+                })
+                .collect(),
+            ValTensor::Instance { .. } => vec![],
         }
     }
 
-    /// gets constant indices
+    /// gets constants
     pub fn get_const_indices(&self) -> Vec<usize> {
-        let size_threshold = 1_000_000; // Tuned using the benchmarks
-
-        if self.len() < size_threshold {
-            // Use single-threaded for smaller arrays
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(i, e)| {
-                        match e {
-                            // Combine both match arms to reduce branching
-                            ValType::Constant(_) | ValType::AssignedConstant(_, _) => Some(i),
-                            _ => None,
-                        }
-                    })
-                    .collect(),
-                ValTensor::Instance { .. } => vec![],
-            }
-        } else {
-            // Use parallel for larger arrays
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .par_chunks(chunk_size)
-                    .enumerate()
-                    .flat_map(|(chunk_idx, chunk)| {
-                        chunk
-                            .par_iter() // Make sure we use par_iter() here
-                            .enumerate()
-                            .filter_map(move |(i, e)| match e {
-                                ValType::Constant(_) | ValType::AssignedConstant(_, _) => {
-                                    Some(chunk_idx * chunk_size + i)
-                                }
-                                _ => None,
-                            })
-                    })
-                    .collect::<Vec<_>>(),
-                ValTensor::Instance { .. } => vec![],
-            }
+        match self {
+            ValTensor::Value { inner: v, .. } => v
+                .par_iter()
+                .enumerate()
+                .filter_map(|(i, e)| {
+                    if let ValType::Constant(_) = e {
+                        Some(i)
+                    } else if let ValType::AssignedConstant(_, _) = e {
+                        Some(i)
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            ValTensor::Instance { .. } => vec![],
         }
     }