hdim-opt 1.3.0__tar.gz → 1.3.2__tar.gz

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/PKG-INFO

@@ -1,19 +1,33 @@
 Metadata-Version: 2.4
 Name: hdim_opt
-Version: 1.3.0
-Summary: Optimization toolkit for high-dimensional, non-differentiable problems.
+Version: 1.3.2
+Summary: High-dimensional numerical optimization and sampling toolkit for complex, non-differentiable problems.
 Author-email: Julian Soltes <jsoltes@regis.edu>
 License: MIT
+Project-URL: Homepage, https://github.com/jgsoltes/hdim_opt
 Project-URL: Repository, https://github.com/jgsoltes/hdim_opt
-Keywords: optimization,high-dimensional,sampling,QUASAR,hyperellipsoid
+Project-URL: Issues, https://github.com/jgsoltes/hdim_opt/issues
+Project-URL: Changelog, https://github.com/jgsoltes/hdim_opt/releases
+Keywords: optimization,high-dimensional,sampling,QUASAR,hyperellipsoid,evolutionary-algorithm,non-differentiable,global-optimization,stochastic-optimization,black-box-optimization
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Natural Language :: English
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
@@ -28,13 +42,14 @@ Requires-Dist: SALib; extra == "sensitivity"
 
 # hdim-opt: High-Dimensional Optimization Toolkit
 
-A modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, and signal waveform decomposition.
+Modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, signal waveform decomposition, and data transformations.
 
 All core functions, listed below, are single-line executable and require three essential parameters: [obj_function, bounds, n_samples].
 * **quasar**: QUASAR optimization for high-dimensional, non-differentiable problems.
-* **hds**: Generate an exploitative HDS sequence, to distribute samples in focused regions.
+* **hyperellipsoid**: Generate a non-uniform Hyperellipsoid Density sequence, to focus sample distributions.
 * **sobol**: Generate a uniform Sobol sequence (via SciPy).
 * **sensitivity**: Perform Sobol sensitivity analysis to measure each variable's importance on objective function results (via SALib).
+* **isotropize**: Isotropizes the input matrix.
 * **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
@@ -63,7 +78,7 @@ time, pulse = h.waveform_analysis.e1_waveform()
 solution, fitness = h.quasar(obj_func, bounds)
 sens_matrix = h.sensitivity(obj_func, bounds)
 
-hds_samples = h.hds(n_samples, bounds)
+hds_samples = h.hyperellipsoid(n_samples, bounds)
 sobol_samples = h.sobol(n_samples, bounds)
 isotropic_samples = h.isotropize(sobol_samples)
 
@@ -75,7 +90,7 @@ signal_data = h.waveform(x=time,y=pulse)
 
 * Benefit: Significant improvements in convergence speed and solution quality compared to contemporary optimizers. (Reference: [https://arxiv.org/abs/2511.13843]).
 
-## HDS Sampler (Hyperellipsoid Density Sampling)
-**HDS** is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
+## HDS Sampler
+**HDS** (Hyperellipsoid Density Sampling) is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
 
 * Benefit: Provides control over the sample distribution. Results in higher average optimization solution quality when used for population initialization compared to uniform QMC methods. (Reference: [https://arxiv.org/abs/2511.07836]).

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/README.md

@@ -1,12 +1,13 @@
 # hdim-opt: High-Dimensional Optimization Toolkit
 
-A modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, and signal waveform decomposition.
+Modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, signal waveform decomposition, and data transformations.
 
 All core functions, listed below, are single-line executable and require three essential parameters: [obj_function, bounds, n_samples].
 * **quasar**: QUASAR optimization for high-dimensional, non-differentiable problems.
-* **hds**: Generate an exploitative HDS sequence, to distribute samples in focused regions.
+* **hyperellipsoid**: Generate a non-uniform Hyperellipsoid Density sequence, to focus sample distributions.
 * **sobol**: Generate a uniform Sobol sequence (via SciPy).
 * **sensitivity**: Perform Sobol sensitivity analysis to measure each variable's importance on objective function results (via SALib).
+* **isotropize**: Isotropizes the input matrix.
 * **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
@@ -35,7 +36,7 @@ time, pulse = h.waveform_analysis.e1_waveform()
 solution, fitness = h.quasar(obj_func, bounds)
 sens_matrix = h.sensitivity(obj_func, bounds)
 
-hds_samples = h.hds(n_samples, bounds)
+hds_samples = h.hyperellipsoid(n_samples, bounds)
 sobol_samples = h.sobol(n_samples, bounds)
 isotropic_samples = h.isotropize(sobol_samples)
 
@@ -47,7 +48,7 @@ signal_data = h.waveform(x=time,y=pulse)
 
 * Benefit: Significant improvements in convergence speed and solution quality compared to contemporary optimizers. (Reference: [https://arxiv.org/abs/2511.13843]).
 
-## HDS Sampler (Hyperellipsoid Density Sampling)
-**HDS** is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
+## HDS Sampler
+**HDS** (Hyperellipsoid Density Sampling) is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
 
 * Benefit: Provides control over the sample distribution. Results in higher average optimization solution quality when used for population initialization compared to uniform QMC methods. (Reference: [https://arxiv.org/abs/2511.07836]).

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt/__init__.py

@@ -4,14 +4,15 @@
 
 Functions:
 	- quasar: QUASAR optimization for high-dimensional, non-differentiable problems.
-	- hds: Generate an exploitative HDS sequence, to distribute samples in focused regions.
+	- hyperellipsoid: Generate a non-uniform hyperellipsoid density sequence.
 	- sobol: Generate a uniform Sobol sequence (via SciPy).
 	- sensitivity: Perform Sobol sensitivity analysis to measure each variable's importance on objective function results (via SALib).
+	- isotropize/deisotropize: Isotropize the input matrix using ZCA.
 	- waveform: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 Modules:
 	- test_functions: Contains test functions for local optimization testing.
-	- waveform_analysis: Contains pulse generation functions.
+	- waveform_analysis: Contains pulse signal generation functions.
 
 Example Usage:
 
@@ -29,7 +30,7 @@ Example Usage:
 	>>> solution, fitness = h.quasar(obj_func, bounds)
 	>>> sens_matrix = h.sensitivity(obj_func, bounds)
 
-	>>> hds_samples = h.hds(n_samples, bounds)
+	>>> hds_samples = h.hyperellipsoid(n_samples, bounds)
 	>>> sobol_samples = h.sobol(n_samples, bounds)
 	>>> isotropic_samples = h.isotropize(sobol_samples)
 
@@ -37,17 +38,17 @@ Example Usage:
 """
 
 # package version
-__version__ = "1.3.0"
-__all__ = ['quasar', 'hds', 'sobol', 'sensitivity', 'test_functions', 'quasar_helpers'] # available for star imports
+__version__ = "1.3.2"
+__all__ = ['quasar','hyperellipsoid','sensitivity','waveform','sobol','isotropize','deisotropize',
+				'test_functions','quasar_helpers','waveform_analysis'] # available for star imports
 
 # import core components
 from .quasar_optimization import optimize as quasar
-from .hyperellipsoid_sampling import sample as hds
-from .sobol_sampling import sobol_sample as sobol
+from .hyperellipsoid_sampling import sample as hyperellipsoid
+from .sobol_sensitivity import sobol_sample as sobol
 from .sobol_sensitivity import sens_analysis as sensitivity
+from .quasar_helpers import isotropize, deisotropize
 from .waveform_analysis import analyze_waveform as waveform
-from .quasar_helpers import isotropize
-from .quasar_helpers import deisotropize
 from . import test_functions
 from . import quasar_helpers
 from . import waveform_analysis

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt/hyperellipsoid_sampling.py

@@ -1,14 +1,15 @@
-# global epslion
-epsilon = 1e-12
+# global epsilon
+epsilon = 1e-16
+import numpy as np
 
 ### misc helper functions 
 
-def sample_hypersphere(n_dimensions, radius, n_samples_in_sphere, radius_qmc_sequence):
+def sample_hypersphere(n_dimensions, radius, 
+                       n_samples_in_sphere, radius_qmc_sequence):
     '''
     Objective:
         - Samples unit hyperspheres using Marsaglia polar vectors scaled by a QMC sequence.
     '''
-    import numpy as np
     
     # generate normal distribution (for angular direction)
     samples = np.random.normal(size=(n_samples_in_sphere, n_dimensions))
@@ -28,14 +29,15 @@ def sample_hypersphere(n_dimensions, radius, n_samples_in_sphere, radius_qmc_seq
     
     return samples
 
-def sample_hyperellipsoid(n_dimensions, n_samples_in_ellipsoid, origin, pca_components, pca_variances, scaling_factor, radius_qmc_sequence=None):
+def sample_hyperellipsoid(n_dimensions, n_samples_in_ellipsoid, 
+                          origin, pca_components, pca_variances, 
+                          scaling_factor, radius_qmc_sequence=None):
     '''
     Objective:
         - Generates samples inside the hyperellipsoid.
             - Calls the function to sample unit hyperspheres.
             - Transforms the hyperspherical samples to the ellipsoid axes defined using the PCA variances.
     '''
-    import numpy as np
     
     # generate samples in unit hypersphere
     unit_sphere_samples = sample_hypersphere(n_dimensions, 1.0, n_samples_in_ellipsoid, radius_qmc_sequence)
@@ -61,7 +63,6 @@ def sample_in_voids(existing_samples, n_to_fill, bounds_min, bounds_max,
     '''
     from sklearn.neighbors import BallTree
     from sklearn.random_projection import GaussianRandomProjection
-    import numpy as np
     from scipy import stats
     import time
     
@@ -146,14 +147,14 @@ def sample_in_voids(existing_samples, n_to_fill, bounds_min, bounds_max,
     
     return new_samples
 
-def fit_pca_for_cluster(cluster_samples, current_origin, initial_samples_std, n_dimensions):
+def fit_pca_for_cluster(cluster_samples, current_origin, 
+                        initial_samples_std, n_dimensions):
     '''
     Performs PCA on a single cluster's samples or returns a default, 
     called in parallel.
     '''
 
     from sklearn.decomposition import PCA
-    import numpy as np
     
     # extract shape
     n_cluster_samples = len(cluster_samples)
@@ -174,11 +175,12 @@ def fit_pca_for_cluster(cluster_samples, current_origin, initial_samples_std, n_
                 'variances': fixed_variance}
 
 
-# main sample function
+### main sampling function
 
 def sample(n_samples, bounds,
            weights=None, normalize=False,
            n_ellipsoids=None, n_initial_clusters=None, n_initial_qmc=None,
+           ellipsoid_scaling_factor=None,
            seed=None, plot_dendrogram=False, verbose=False):
     '''
     Objective:
@@ -208,7 +210,6 @@ def sample(n_samples, bounds,
 
     # imports
     try:
-        import numpy as np
         import pandas as pd
         from scipy import stats
         from joblib import Parallel, delayed
@@ -367,11 +368,12 @@ def sample(n_samples, bounds,
     confidence_level = 0.9999 # captures 99.99% of cluster's samples
 
     # critical value (the statistical radius squared)
-    chi2_critical_value = stats.chi2.ppf(confidence_level, df=n_dimensions)
-    baseline_factor = 0.55 - 0.01*np.log(n_dimensions) # empirically derived to resample out-of-bounds points
-    
-    # square root as the scaling factor (Mahalanobis distance)
-    ellipsoid_scaling_factor = baseline_factor * np.sqrt(chi2_critical_value)
+    if ellipsoid_scaling_factor == None:
+        chi2_critical_value = stats.chi2.ppf(confidence_level, df=n_dimensions)
+        baseline_factor = 0.55 - 0.01*np.log(n_dimensions) # empirically derived to resample out-of-bounds points
+        
+        # square root as the scaling factor (Mahalanobis distance)
+        ellipsoid_scaling_factor = baseline_factor * np.sqrt(chi2_critical_value)
 
     # QMC sequence for radius scaling
     radius_qmc_sampler = stats.qmc.Sobol(d=1, seed=seed+1) # offset seed from initial qmc
@@ -522,7 +524,6 @@ def sample(n_samples, bounds,
 
         
         ### PCA for n_dim > 2:
-        
         if normalize:
             data_to_plot_raw = initial_samples
         else:
@@ -546,8 +547,6 @@ def sample(n_samples, bounds,
             xlabel_str = f'Dimension 0'
             ylabel_str = f'Dimension 1'
 
-        # dark visualization parameters for better sample visuals
-
         # samples
         fig, ax = plt.subplots(1,2,figsize=(9,5))
         
@@ -566,7 +565,6 @@ def sample(n_samples, bounds,
         ax[0].set_title(title_str, fontsize=14)
         ax[0].set_xlabel(xlabel_str)
         ax[0].set_ylabel(ylabel_str)
-        # ax[0].axis(False)
         ax[0].legend(loc=(0.7,0.87), fontsize=8)
 
         # plot histograms

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt/quasar_helpers.py

@@ -1,56 +1,53 @@
 # global imports
-import pandas as pd
-from sklearn.preprocessing import StandardScaler
 import numpy as np
-from scipy.linalg import cholesky, solve_triangular
-epsilon = 1e-12
+epsilon = 1e-16
 
 def isotropize(data):
     '''
     Objective: 
-        - Converts data to isotropic space. Removes correlations and scales to mean and variance.
-        - Promotes optimization stability.
-    Inputs: 
-        - data: Input data.
-    Outputs: 
-        - data_isotropic: Isotropized data.
-        - metadata: Scaler and whitening matrix 
+        - Isotropizes the input matrix using Zero-Phase Component Analysis (ZCA).
+            - Maintains original parameter orientation while removing correlations.
+        - 'deisotropize' function inverse transforms to the original parameter space.
     '''
-    
+    from scipy.linalg import eigh
     # convert to array
     X = np.array(data)
     
     # standard scaling (mean = 0, var = 1)
     mean = np.mean(X, axis=0)
-    stdev = np.std(X, axis=0)
+    stdev = np.std(X, axis=0) + epsilon # add epsilon to avoid div0
     X_centered = (X - mean) / stdev
     
-    # whitening parameters
-    n_dims = X_centered.shape[1]
-    cov = np.cov(X_centered, rowvar=False) + np.eye(n_dims) * epsilon
-    L = cholesky(cov, lower=True)
+    # eigen-decomposition of the correlation matrix
+    cov = np.cov(X_centered, rowvar=False) + np.eye(X_centered.shape[1]) * epsilon
+    eigenvalues, eigenvectors = eigh(cov) # eigh is more stable for symmetric matrices like covariance
     
-    # transform Y = (X_centered) @ (L^-1).T
-    data_iso = solve_triangular(L, X_centered.T, lower=True).T
+    # ZCA whitening matrix: W_zca = U @ diag(1/sqrt(lambda)) @ U.T
+    diag_inv_sqrt = np.diag(1.0 / np.sqrt(np.maximum(eigenvalues, epsilon))) # use maximum to avoid div0
+    W_zca = eigenvectors @ diag_inv_sqrt @ eigenvectors.T # whitening matrix
+    W_zca_inv = (eigenvectors * np.sqrt(np.maximum(eigenvalues, epsilon))) @ eigenvectors.T # save for deisotropization
+
+    # transform: y = X_centered @ W_zca.T
+    data_iso = np.dot(X_centered, W_zca) # no .T needed because W_zca is symmetric
     
     # store parameters for deisotropization
     params = {
         'mean': mean,
         'stdev': stdev,
-        'L': L
+        'W_zca_inv': W_zca_inv
     }
     return data_iso, params
 
 def deisotropize(data_iso, params):
-    '''De-isotropize data to its original parameter space.'''
+    '''De-isotropize data to its original parameter space via inverse ZCA.'''
     
-    # reverse whitening: X_centered = Y @ L.T
-    data_centered = np.dot(data_iso, params['L'].T)
+    # inverse ZCA: X_centered = y @ W_zca_inv.T
+    data_centered = np.dot(data_iso, params['W_zca_inv'].T)
     
-    # reverse scaling: X = (X_centered * std) + mean
+    # inverse scaling: X = (X_centered * std) + mean
     data_original = (data_centered * params['stdev']) + params['mean']
     return data_original
-
+    
 ############## CONSTRAINTS ##############
 def apply_penalty(fitnesses, solutions, constraints, constraint_penalty, vectorized):
     '''

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt/quasar_optimization.py

@@ -164,7 +164,6 @@ def evolve_generation(obj_function, population, fitnesses, best_solution,
             
         # greedy elitism selection
         selection_indices = trial_fitnesses < fitnesses
-        
         new_population = np.where(selection_indices[np.newaxis, :], trial_vectors, population)
         new_fitnesses = np.where(selection_indices, trial_fitnesses, fitnesses)
         
@@ -263,7 +262,7 @@ def evolve_generation(obj_function, population, fitnesses, best_solution,
         
     return new_population, new_fitnesses
 
-def asym_reinit(population, current_fitnesses, bounds, reinit_method, seed, vectorized):
+def asym_reinit(population, current_fitnesses, bounds, reinit_method, seed, generation, vectorized):
     '''
     Objective:
         - Reinitializes the worst 33% solutions in the population.
@@ -340,7 +339,7 @@ def asym_reinit(population, current_fitnesses, bounds, reinit_method, seed, vect
     elif reinit_method == 'sobol':
         
         # generate sobol samples
-        sobol_sampler = stats.qmc.Sobol(d=dimensions, seed=seed) 
+        sobol_sampler = stats.qmc.Sobol(d=dimensions, seed=seed+generation) 
         sobol_samples_unit = sobol_sampler.random(n=num_to_replace)
         
         bounds_low = bounds[:, 0]
@@ -367,14 +366,13 @@ def asym_reinit(population, current_fitnesses, bounds, reinit_method, seed, vect
     
 
 # main optimize function
-
 def optimize(func, bounds, args=(),
               init='sobol', popsize=None, maxiter=100,
               entangle_rate=0.33, polish=True, polish_minimizer=None,
-              patience=np.inf, vectorized=False,
-              hds_weights=None, kwargs={},
+              patience=np.inf, tolerance=-np.inf, vectorized=False,
+              kwargs={},
               constraints=None, constraint_penalty=1e9,
-              reinitialization_method='covariance',
+              reinitialization='covariance', hds_weights=None,
               verbose=True, plot_solutions=True, num_to_plot=10, plot_contour=True,
               workers=1, seed=None
               ):
@@ -382,7 +380,6 @@ def optimize(func, bounds, args=(),
     Objective:
         - Finds the optimal solution for a given objective function.
         - Designed for non-differentiable, high-dimensional problems.
-        - For explorative problems chance reinitialization_method to '
         - Test functions available for local testing, called as hdim_opt.test_functions.function_name.
             - Existing test functions: [rastrigin, ackley, sinusoid, sphere, shubert].
             
@@ -393,31 +390,30 @@ def optimize(func, bounds, args=(),
         - kwargs: Dictionary of keyword arguments for the objective function.
 
         - init: Initial population sampling method. 
-            - Defaults to 'sobol'. (Recommended power-of-2 population sizes for maximum uniformity).
+            - Defaults to 'sobol' (recommended power-of-2 population sizes for maximum uniformity).
             - Existing options are:
-                - 'sobol': Sobol (highly uniform QMC; powers of 2 population sizes recommended).
-                - 'hds': Hyperellipsoid Density (non-uniform; density weights 'hds_weights' recommended). 
-                - 'lhs': Latin Hypercube (uniform QMC).
-                - 'random': Random sampling (uniform).
+                - 'sobol': Sobol (spatially uniform; power of 2 population sizes recommended).
+                - 'hds': Hyperellipsoid (non-uniform; density weights 'hds_weights' recommended).
+                - 'lhs': Latin Hypercube (uniform across each dimension).
+                - 'random': Random sampling (quasi-uniform).
                 -  custom population (N x D matrix).
-        - popsize: Number of solution vectors to evolve (default 10 * n_dimensions).
-            - Recommended to be a power of 2 for Sobol initialization.
+        - popsize: Number of solution vectors to evolve (default is next power of 2 of 10 * n_dimensions).
         - maxiter: Number of generations to evolve (default 100).
             
         - entangle_rate: Probability of solutions using the local Spooky-Best mutation strategy.
-            - Defaults to 0.33. This causes to the three mutation strategies to be applied equally. 
+            - Defaults to 0.33; each mutation strategy is applied equally. 
             - Higher implies more exploitation.
+            
         - polish: Boolean to implement final polishing step, using SciPy.optimize.minimize.
-        - polish_minimizer: Minimization function to use for polishing step (using SciPy naming conventions).
+        - polish_minimizer: Name of Scipy minimization function to polish with.
             - Defaults to 'Powell' minimization, or 'SLSQP' if 'constraints' parameter is provided.
-            - Recommended to place constraints in objective function to use Powell.
+            - Accepts all minimizers ('L-BFGS-B', ...).
         
         - patience: Number of generations without improvement before early convergence.
+        - tolerance: Target objective function value for early convergence.
         - vectorized: Boolean to accept vectorized (N,D) objective functions 
-            - Extremely efficient, highly recommended whenever possible.
+            - Highly efficient, recommended when possible.
         
-        - hds_weights: Optional weights for hyperellipsoid density sampling initialization.
-            - {0 : {'center' : center, 'std': stdev}, 1: {...} }
         - kwargs: Dictionary of keyword arguments for the objective function.
 
         - constraints: Dictionary of constraints to penalize.
@@ -433,11 +429,13 @@ def optimize(func, bounds, args=(),
                                         }
         - constraint_penalty: Penalty applied to each constraint violated, defaults to 1e12.
 
-        - reinitialization_method: Type of re-sampling to use in the asymptotic reinitialization.
+        - reinitialization: Type of re-sampling to use in the asymptotic reinitialization.
             - Options are ['covariance', 'sobol'].
-            - 'covariance' (exploitative) is default for most problems.
+            - 'covariance' (exploitative) is default for N > D problems.
             - 'sobol' (explorative) is optional, for high exploration and faster computation.
             - None to disable reinitialization calculations.
+        - hds_weights: Optional weights for hyperellipsoid density sampling initialization.
+            - {0 : {'center' : center, 'std': stdev}, 1: {...} }
         
         - verbose: Displays prints and plots.
             - Mutation factor distribution shown with hdim_opt.test_functions.plot_mutations()
@@ -446,7 +444,7 @@ def optimize(func, bounds, args=(),
         
         - workers: Number of workers / jobs / cores to use.
             - Default is 1. Set to -1 to use all available.
-            - If workers != 1, constraint & objective functions must be imported from external module, for pickling.
+            - If workers != 1, constraint & objective functions must be imported from external module for pickling.
         - seed: Random seed for deterministic & reproducible results.
         
     Outputs:
@@ -499,10 +497,7 @@ def optimize(func, bounds, args=(),
     # ensure bounds is array; shape (n_dimensions,2)
     bounds = np.array(bounds)
     n_dimensions = bounds.shape[0]
-
-    if n_dimensions == 1:
-        reinitialization = False
-        
+    
     # if init is not a string, assume it is a custom population
     if not isinstance(init, str):
         popsize = init.shape[0]
@@ -516,7 +511,11 @@ def optimize(func, bounds, args=(),
     # ensure integers
     popsize, maxiter = int(popsize), int(maxiter)
 
+    # map to sobol if N < D
+    if n_dimensions == 1:
+        reinitialization = None
     
+        
     ################################# INPUT ERRORS #################################
     
     # entangle rate error
@@ -528,8 +527,8 @@ def optimize(func, bounds, args=(),
         raise ValueError("Initial sampler must be one of ['sobol','random','hds','lhs'], or a custom population.")
     
     # patience error
-    if patience <= 1:
-        raise ValueError('Patience must be > 1 generation.')
+    if patience < 1:
+        raise ValueError('Patience must be > 0 generations.')
 
     
     ################################# INITIAL POPULATION #################################
@@ -537,11 +536,11 @@ def optimize(func, bounds, args=(),
     # generate initial population
     initial_population = initialize_population(popsize, bounds, init, hds_weights, seed, verbose)
     if verbose:
-        if reinitialization_method not in ['sobol', 'covariance', None]:
-            print("reinitialization_method must be one of ['covariance', 'sobol', None].")
+        if reinitialization not in ['sobol', 'covariance', None]:
+            print("reinitialization must be one of ['covariance', 'sobol', None].")
             print(f'\nEvolving (None):')
         else:
-            print(f'\nEvolving ({reinitialization_method}):')
+            print(f'\nEvolving ({reinitialization}):')
 
     # match differential evolution conventions    
     if vectorized:
@@ -648,12 +647,12 @@ def optimize(func, bounds, args=(),
         # apply asymptotic covariance reinitialization to population
         final_proba = 0.33
         decay_generation = 0.33
-        if reinitialization_method in ['sobol','covariance']:
+        if (reinitialization in ['sobol','covariance']):
             reinit_proba = np.e**((np.log(final_proba)/(decay_generation*maxiter))*generation)
         else:
             reinit_proba = 0.0
         if np.random.rand() < reinit_proba:
-            population = asym_reinit(population, current_fitnesses, bounds, reinitialization_method, seed, vectorized=vectorized)
+            population = asym_reinit(population, current_fitnesses, bounds, reinitialization, seed, generation, vectorized=vectorized)
 
         # clip population to bounds
         if vectorized:
@@ -663,19 +662,19 @@ def optimize(func, bounds, args=(),
 
         # add to population history
         if verbose:
-          # determine which solutions to sample
-          if popsize <= num_to_plot:
-              indices_to_sample = np.arange(popsize)
-          else:
-              indices_to_sample = np.random.choice(popsize, num_to_plot, replace=False)
-        
-          if vectorized:
-              sampled_population = population[:, indices_to_sample].T.copy()
-          else:
-              sampled_population = population[indices_to_sample].copy()
-              
-          pop_history.append(sampled_population)
-          best_history.append(best_solution.copy())
+            # determine which solutions to sample
+            if popsize <= num_to_plot:
+                indices_to_sample = np.arange(popsize)
+            else:
+                indices_to_sample = np.random.choice(popsize, num_to_plot, replace=False)
+            
+            if vectorized:
+                sampled_population = population[:, indices_to_sample].T.copy()
+            else:
+                sampled_population = population[indices_to_sample].copy()
+            
+            pop_history.append(sampled_population)
+            best_history.append(best_solution.copy())
 
         # print generation status
         if verbose:
@@ -683,11 +682,14 @@ def optimize(func, bounds, args=(),
             print(f' Gen. {generation+1}/{maxiter} | f(x)={best_fitness:.2e} | stdev={stdev:.2e} | reinit={reinit_proba:.2f}')
 
         # patience for early convergence
-        if (generation - last_improvement_gen) > patience:
+        if last_improvement_gen >= patience:
             if verbose:
-                print(f'\nEarly convergence: number of generations without improvement exceeds patience ({patience}).')
+                print(f'Early convergence: patience exceeded ({patience}).')
+            break
+        if best_fitness <= tolerance:
+            if verbose:
+                print(f'Early convergence: f(x) below tolerance ({tolerance:.2e}).')
             break
-
     
     ################################# POLISH #################################
     
@@ -703,7 +705,7 @@ def optimize(func, bounds, args=(),
                                         maxiter=maxiter, vectorized=vectorized, constraints=constraints, 
                                         args=args, kwargs=kwargs, 
                                         polish_minimizer=polish_minimizer, verbose=verbose
-    )
+        )
 
     
     ################################# VERBOSE #################################

hdim_opt-1.3.2/hdim_opt/sobol_sensitivity.py

@@ -0,0 +1,185 @@
+import numpy as np
+from scipy import stats
+
+### sensitivity analysis
+def sens_analysis(func, bounds, n_samples=2**7, 
+                  args=None, kwargs=None, 
+                  param_names=None, calc_second_order=True, 
+                  log_scale=False, num_to_plot=10, verbose=True):
+    '''
+    Objective:
+        - Perform global Sobol sensitivity analysis on the objective function.
+        - Utilizes the SALib package.
+    Inputs:
+        - func: Objective function (Problem) to analyze.
+        - bounds: Parameter space bounds, as an array of tuples.
+        - n_samples: Number of Sobol samples to generate.
+        - kwargs: Keyword arguments (dictionary) for objective function.
+        - param_names: Optional parameter names for each dimension.
+        - calc_second_order: Boolean to calculate second-order interactions. Disable to improve computation speed.
+        - log_scale: Boolean to log-scale plots.
+        - num_to_plot: Number of dimensions to plot.
+        - verbose: Boolean to display plots.
+    Outputs:
+        - Si: Matrix of first- and total-order sensitivity indices and confidences.
+        - S2_matrix: Matrix of second-order interactions.
+    '''
+
+    ### imports
+    try:
+        import numpy as np
+        from SALib.sample import sobol as sobol_sample
+        from SALib.analyze import sobol as sobol_analyze
+        import pandas as pd
+        import time
+    except ImportError as e:
+        raise ImportError(f'Sensitivity analysis requires dependencies: (SALib, pandas).') from e
+    
+    ### extract inputs
+    start_time = time.time()
+    bounds = np.array(bounds)
+    n_params = bounds.shape[0]
+    if param_names == None:
+        param_names = range(0,n_params)
+    elif len(param_names) != len(bounds):
+        raise ValueError('Length of param_names does not match length of bounds.')
+    
+    ### define problem for SALib
+    problem = {
+        'num_vars': n_params,
+        'names': param_names,
+        'bounds' : bounds
+        }
+
+    ### generate samples
+    if verbose:
+        print(f'Generating Sobol samples (N={n_samples:,.0f}, D={n_params}).')
+    param_values = sobol_sample.sample(problem, n_samples, calc_second_order=calc_second_order)
+
+    ### args / kwargs for the objective function
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
+    def wrapped_func(x_samples):
+        return func(x_samples, *args, **kwargs)
+
+    ### evaluate samples
+    # vectorized evaluation
+    n_expected = param_values.shape[0]
+    try:
+        values = wrapped_func(param_values)
+        values = np.asarray(values).flatten()
+        if values.shape[0] != n_expected:
+            raise ValueError('Non-vectorized objective function.')
+
+    # loop-based evaluation
+    except ValueError as e:
+        if verbose:
+            print(f'Non-vectorized objective function; loop-based evaluation.')
+        values = np.array([wrapped_func(sample) for sample in param_values])
+
+    # run sensitivity analysis
+    print('Running sensitivity analysis.')
+    Si = sobol_analyze.analyze(problem, values, calc_second_order=calc_second_order, print_to_console=False)
+
+    # create Si output dataframe
+    Si_keys = ['S1', 'S1_conf', 'ST', 'ST_conf']
+    Si_filtered = {k: Si[k] for k in Si_keys if k in Si} # filter for output
+    Si_df = pd.DataFrame(Si_filtered, index=param_names)
+
+    # create S2 output dataframe
+    if calc_second_order:
+        S2_matrix = Si['S2']
+        S2_df = pd.DataFrame(S2_matrix, index=param_names, columns=param_names)
+        S2_df = S2_df.fillna(S2_df.T)
+    else:
+        S2_df = pd.DataFrame()
+
+    ### end of calculations
+    end_time = time.time()
+    run_time = end_time - start_time
+    if verbose:
+        num_to_plot = np.minimum(num_to_plot, n_params)
+        print(f'\nRun time: {run_time:.2f}s')
+        # plotting imports
+        try:
+            import matplotlib.pyplot as plt
+            import seaborn as sns
+        except ImportError as e:
+            raise ImportError(f'Plotting requires dependencies: (matplotlib, seaborn).') from e
+
+        # sort by S1
+        sort_idx = np.argsort(Si['S1'])
+        s1_sorted = Si['S1'][sort_idx][-num_to_plot:]
+        st_sorted = Si['ST'][sort_idx][-num_to_plot:]
+        s1_conf_sorted = Si['S1_conf'][sort_idx][-num_to_plot:]
+        st_conf_sorted = Si['ST_conf'][sort_idx][-num_to_plot:]
+        names_sorted = [np.array(param_names)[i] for i in sort_idx][-num_to_plot:]
+        index = np.arange(len(names_sorted))
+
+        ### plot 1: first-order (S1) and total-order (ST) indices
+        fig, ax = plt.subplots(1,1,figsize=(9, 7))
+        
+        bar_width = 0.35
+        ax.barh(index + bar_width/2, s1_sorted, bar_width, xerr=s1_conf_sorted, 
+                   label='First-order ($S_1$)',
+                   alpha=1,
+                   capsize=2.5)
+        ax.set_yticks(index)
+        ax.set_yticklabels(names_sorted)
+    
+        ax.barh(index - bar_width/2, st_sorted, bar_width,
+                   xerr=st_conf_sorted, 
+                   label='Total-order ($S_T$)',
+                   alpha=0.75, 
+                   capsize=2.5)
+        if log_scale:
+            ax.set_xscale('log')
+        ax.set_title('Sensitivity Indices ($S_1$, $S_T$)')
+        ax.legend()
+        plt.tight_layout()
+        plt.show()
+
+        if calc_second_order:
+            ### plot 2: heatmap of second order indices
+            s2_plot, ax = plt.subplots(1,1,figsize=(9, 7))
+            
+            top_idx_to_show = sort_idx[-num_to_plot:]
+            S2_filtered = S2_df.iloc[top_idx_to_show, top_idx_to_show]
+            mask_filtered = np.tril(np.ones_like(S2_filtered, dtype=bool))
+            sns.heatmap(data=S2_filtered, mask=mask_filtered, annot=True, vmin=0.0, fmt='.2f')
+            ax.set_title('Second-order Interactions ($S_2$)')
+            ax.invert_yaxis()
+            plt.tight_layout()
+            plt.show()
+    
+    return Si_df, S2_df
+
+### sobol sampling
+def sobol_sample(n_samples, bounds, normalize=False, seed=None):
+    '''
+    Objective:
+        - Generates a uniform scrambled Sobol sample sequence.
+    Inputs:
+        - n_samples: Number of samples to generate.
+        - bounds: Range to sample over.
+        - normalize: Boolean, if True keeps samples normalized to [0,1].
+        - seed: Random seed.
+    Outputs:
+        - sobol_sequence: Sobol sample sequence.
+    '''
+    
+    # clean bounds & n_dimensions
+    bounds = np.array(bounds)
+    n_dimensions = bounds.shape[0]
+    
+    sobol_sampler = stats.qmc.Sobol(d=n_dimensions, scramble=True, seed=seed)
+    sobol_samples_unit = sobol_sampler.random(n=n_samples)
+    
+    if not normalize:
+        sobol_sequence = stats.qmc.scale(sobol_samples_unit, bounds[:, 0], bounds[:, 1])
+    else:
+        sobol_sequence = sobol_samples_unit
+
+    return sobol_sequence

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt/waveform_analysis.py

@@ -406,7 +406,7 @@ def plot_diagnostic_dashboard(temporal, spectral, metrics):
     ax_cum.plot(f_mhz, spectral['energy'], color='gold', linewidth=2)
     ax_cum.fill_between(f_mhz, spectral['energy'], color='gold', alpha=0.2)
     ax_cum.axvline(metrics['bw_90_hz'], color='red', linestyle='--', 
-                   label=f'90% Band: {metrics['bw_90_hz']:.1f} MHz')
+                   label=f'90% Band: {metrics['bw_90_hz']:.1e} Hz')
     ax_cum.set_title('Cumulative Energy')
     ax_cum.set_ylabel('Normalized Energy')
     ax_cum.set_xlabel('Frequency (MHz)')
@@ -440,7 +440,10 @@ def plot_diagnostic_dashboard(temporal, spectral, metrics):
     im = ax_spec.pcolormesh(t_spec*1e6, f, 10*np.log10(Sxx + epsilon), 
                             shading='gouraud', cmap='plasma')
     
+    ax_spec.set_title('Spectrogram')
     ax_spec.set_yscale('log')
     ax_spec.set_ylim(np.abs(spectral['freq']).min()+epsilon, np.abs(spectral['freq'].max()/sample_rate))
+    cbar = fig.colorbar(im, ax=ax_spec)
+    cbar.set_label('Power/Frequency (dB/Hz)')
 
     plt.show()

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt.egg-info/PKG-INFO

@@ -1,19 +1,33 @@
 Metadata-Version: 2.4
 Name: hdim_opt
-Version: 1.3.0
-Summary: Optimization toolkit for high-dimensional, non-differentiable problems.
+Version: 1.3.2
+Summary: High-dimensional numerical optimization and sampling toolkit for complex, non-differentiable problems.
 Author-email: Julian Soltes <jsoltes@regis.edu>
 License: MIT
+Project-URL: Homepage, https://github.com/jgsoltes/hdim_opt
 Project-URL: Repository, https://github.com/jgsoltes/hdim_opt
-Keywords: optimization,high-dimensional,sampling,QUASAR,hyperellipsoid
+Project-URL: Issues, https://github.com/jgsoltes/hdim_opt/issues
+Project-URL: Changelog, https://github.com/jgsoltes/hdim_opt/releases
+Keywords: optimization,high-dimensional,sampling,QUASAR,hyperellipsoid,evolutionary-algorithm,non-differentiable,global-optimization,stochastic-optimization,black-box-optimization
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Natural Language :: English
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
@@ -28,13 +42,14 @@ Requires-Dist: SALib; extra == "sensitivity"
 
 # hdim-opt: High-Dimensional Optimization Toolkit
 
-A modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, and signal waveform decomposition.
+Modern optimization package to accelerate convergence in complex, high-dimensional problems. Includes the QUASAR evolutionary algorithm, HDS exploitative QMC sampler, Sobol sensitivity analysis, signal waveform decomposition, and data transformations.
 
 All core functions, listed below, are single-line executable and require three essential parameters: [obj_function, bounds, n_samples].
 * **quasar**: QUASAR optimization for high-dimensional, non-differentiable problems.
-* **hds**: Generate an exploitative HDS sequence, to distribute samples in focused regions.
+* **hyperellipsoid**: Generate a non-uniform Hyperellipsoid Density sequence, to focus sample distributions.
 * **sobol**: Generate a uniform Sobol sequence (via SciPy).
 * **sensitivity**: Perform Sobol sensitivity analysis to measure each variable's importance on objective function results (via SALib).
+* **isotropize**: Isotropizes the input matrix.
 * **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
@@ -63,7 +78,7 @@ time, pulse = h.waveform_analysis.e1_waveform()
 solution, fitness = h.quasar(obj_func, bounds)
 sens_matrix = h.sensitivity(obj_func, bounds)
 
-hds_samples = h.hds(n_samples, bounds)
+hds_samples = h.hyperellipsoid(n_samples, bounds)
 sobol_samples = h.sobol(n_samples, bounds)
 isotropic_samples = h.isotropize(sobol_samples)
 
@@ -75,7 +90,7 @@ signal_data = h.waveform(x=time,y=pulse)
 
 * Benefit: Significant improvements in convergence speed and solution quality compared to contemporary optimizers. (Reference: [https://arxiv.org/abs/2511.13843]).
 
-## HDS Sampler (Hyperellipsoid Density Sampling)
-**HDS** is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
+## HDS Sampler
+**HDS** (Hyperellipsoid Density Sampling) is a non-uniform Quasi-Monte Carlo sampling method, specifically designed to exploit promising regions of the search space.
 
 * Benefit: Provides control over the sample distribution. Results in higher average optimization solution quality when used for population initialization compared to uniform QMC methods. (Reference: [https://arxiv.org/abs/2511.07836]).

{hdim_opt-1.3.0 → hdim_opt-1.3.2}/hdim_opt.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ hdim_opt/__init__.py
 hdim_opt/hyperellipsoid_sampling.py
 hdim_opt/quasar_helpers.py
 hdim_opt/quasar_optimization.py
-hdim_opt/sobol_sampling.py
 hdim_opt/sobol_sensitivity.py
 hdim_opt/test_functions.py
 hdim_opt/waveform_analysis.py

hdim_opt-1.3.2/pyproject.toml

@@ -0,0 +1,76 @@
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hdim_opt"
+version = "1.3.2" # match version in __init__.py
+description = "High-dimensional numerical optimization and sampling toolkit for complex, non-differentiable problems."
+readme = {file = "README.md", content-type = "text/markdown"}
+
+authors = [
+  {name="Julian Soltes", email="jsoltes@regis.edu"}
+]
+
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = [
+    "optimization", 
+    "high-dimensional", 
+    "sampling", 
+    "QUASAR", 
+    "hyperellipsoid",
+    "evolutionary-algorithm",
+    "non-differentiable",
+    "global-optimization",
+    "stochastic-optimization",
+    "black-box-optimization"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Natural Language :: English",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Bio-Informatics"
+]
+dependencies = ["numpy", "scipy"]
+
+[project.optional-dependencies]
+hds = [
+    # required by HDS `pip install hdim_opt[hds]`
+    "pandas",
+    "scikit-learn", 
+    "joblib"
+]
+
+sensitivity = [
+    # required by sensitivity `pip install hdim_opt[sensitivity]`
+    "pandas",
+    "SALib"
+]
+
+[project.urls]
+Homepage = "https://github.com/jgsoltes/hdim_opt"
+Repository = "https://github.com/jgsoltes/hdim_opt"
+Issues = "https://github.com/jgsoltes/hdim_opt/issues"
+Changelog = "https://github.com/jgsoltes/hdim_opt/releases"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hdim_opt*"] # find hdim_opt package

hdim_opt-1.3.0/hdim_opt/sobol_sampling.py

@@ -1,29 +0,0 @@
-from scipy import stats
-import numpy as np
-
-def sobol_sample(n_samples, bounds, normalize=False, seed=None):
-    '''
-    Objective:
-        - Generate a uniform scrambled Sobol sample sequence.
-    Inputs:
-        - n_samples: Number of samples to generate.
-        - bounds: Range to sample over.
-        - normalize: Boolean, if True keeps samples normalized to [0,1].
-        - seed: Random seed.
-    Outputs:
-        - sobol_sequence: Sobol sample sequence.
-    '''
-    
-    # clean bounds & n_dimensions
-    bounds = np.array(bounds)
-    n_dimensions = bounds.shape[0]
-    
-    sobol_sampler = stats.qmc.Sobol(d=n_dimensions, scramble=True, seed=seed)
-    sobol_samples_unit = sobol_sampler.random(n=n_samples)
-    
-    if not normalize:
-        sobol_sequence = stats.qmc.scale(sobol_samples_unit, bounds[:, 0], bounds[:, 1])
-    else:
-        sobol_sequence = sobol_samples_unit
-
-    return sobol_sequence

hdim_opt-1.3.0/hdim_opt/sobol_sensitivity.py

@@ -1,125 +0,0 @@
-def sens_analysis(func, bounds, n_samples=None, 
-                  kwargs=None, param_names=None,
-                  verbose=True, log_scale=True):
-    '''
-    Objective:
-        - Perform Sobol sensitivity analysis on the vectorized objective function.
-    Inputs:
-        - func: Objective function (Problem) to analyze.
-        - bounds: Parameter space bounds, as an array of tuples.
-        - n_samples: Number of Sobol samples to generate.
-        - kwargs: Keyword arguments (dictionary) for objective function.
-        - param_names: Optional parameter names for each dimension.
-        - verbose: Boolean to display plots.
-        - log_scale: Boolean to log-scale plots.
-    Outputs:
-        - Si: Full sensitivity indices and confidences.
-        - S2_matrix: Matrix of S2 relationship sensitivity indices.
-    '''
-
-    # imports
-    try:
-        import numpy as np
-        from SALib.sample import sobol as sobol_sample
-        from SALib.analyze import sobol as sobol_analyze
-        import pandas as pd
-        from functools import partial
-    except ImportError as e:
-        raise ImportError(f'Sensitivity analysis requires dependencies: (SALib, pandas, functools).') from e
-    
-    
-    # define input parameters and their ranges
-    bounds = np.array(bounds)
-    n_params = bounds.shape[0]
-    if param_names == None:
-        param_names = range(0,n_params)
-
-    # scale default n_samples by dimension (power of 2)
-    if n_samples == None:
-        n_samples = int(2**np.ceil(np.log2(10*n_params)))
-
-    # define problem
-    problem = {
-        'num_vars': n_params,
-        'names': param_names,
-        'bounds' : bounds
-        }
-
-    # generate samples
-    if verbose:
-        print(f'Generating {n_samples:,.0f} Sobol samples for sensitivity analysis.')
-    param_values = sobol_sample.sample(problem, n_samples)
-
-    # kwargs for the objective function
-    if kwargs:
-        func = partial(func, **kwargs)
-        
-    # evaluate the samples
-    values = func(param_values) 
-    
-    # running sensitivity analysis
-    print('Running sensitivity analysis.')
-    Si = sobol_analyze.analyze(problem, values, calc_second_order=True, print_to_console=False)
-
-    # calculate S2 sensitivities
-    # convert S2 indices to dataframe to process easier
-    S2_matrix = Si['S2']
-    S2_df = pd.DataFrame(S2_matrix, index=param_names, columns=param_names)
-    S2_df = S2_df.fillna(S2_df.T)
-    mask = np.tril(np.ones_like(S2_df, dtype=bool))
-
-    if verbose:
-        # import
-        try:
-            import matplotlib.pyplot as plt
-            import seaborn as sns
-        except ImportError as e:
-            raise ImportError(f'Plotting requires dependencies: (matplotlib, seaborn).') from e
-
-        # sort by S1 values
-        sort_idx = np.argsort(Si['S1'])
-        s1_sorted = Si['S1'][sort_idx]
-        st_sorted = Si['ST'][sort_idx]
-        s1_conf_sorted = Si['S1_conf'][sort_idx]
-        st_conf_sorted = Si['ST_conf'][sort_idx]
-        names_sorted = [np.array(param_names)[i] for i in sort_idx]
-    
-        
-        bar_width = 0.35
-        index = np.arange(n_params)
-        
-        # plot 1: first-order (S1) and total-order (ST) indices
-        sens_plot, axs = plt.subplots(2,1,figsize=(9, 13)) 
-        
-        # define bar width and positions
-        bar_width = 0.35
-        index = np.arange(n_params)
-        
-        # plot S1 (first order) sensitivities
-        axs[0].barh(index - bar_width/2, s1_sorted, bar_width,
-                   xerr=s1_conf_sorted, 
-                   label='First-order ($S_1$)',
-                   alpha=1,
-                   capsize=2.5)
-        
-        axs[0].barh(index + bar_width/2, st_sorted, bar_width,
-                   xerr=st_conf_sorted, 
-                   label='Total-order ($S_T$)',
-                   alpha=0.75, 
-                   capsize=2.5)
-
-        axs[0].set_title('Sensitivity Indices ($S_1$, $S_T$)')
-        if log_scale:
-            axs[0].set_xscale('log')
-        
-        axs[0].set_yticks(index)
-        axs[0].set_yticklabels(names_sorted)
-        
-        # plot 2: heatmap of second order indices
-        sns.heatmap(data=S2_df, mask=mask, cbar_kws={'label': 'Second-order Index ($S_2$)'},ax=axs[1]) # magma
-        axs[1].set_title('Second-order Interactions ($S_2$)')
-        axs[1].invert_yaxis()
-        sens_plot.tight_layout() 
-        plt.show()
-    
-    return Si, S2_matrix

hdim_opt-1.3.0/pyproject.toml

@@ -1,51 +0,0 @@
-# pyproject.toml
-
-[build-system]
-requires = ["setuptools>=61.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "hdim_opt"
-version = "1.3.0" # match __version__ in __init__.py
-description = "Optimization toolkit for high-dimensional, non-differentiable problems."
-readme = {file = "README.md", content-type = "text/markdown"}
-
-authors = [
-  {name="Julian Soltes", email="jsoltes@regis.edu"}
-]
-
-license = { text = "MIT" }
-requires-python = ">=3.8"
-keywords = ["optimization", "high-dimensional", "sampling", "QUASAR", "hyperellipsoid"]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Intended Audience :: Science/Research",
-    "Intended Audience :: Developers",
-    "Topic :: Scientific/Engineering :: Mathematics",
-    "Topic :: Scientific/Engineering :: Physics",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence"
-]
-dependencies = ["numpy", "scipy"]
-
-[project.optional-dependencies]
-hds = [
-    # required by HDS `pip install hdim_opt[hds]`
-    "pandas",
-    "scikit-learn", 
-    "joblib"
-]
-
-sensitivity = [
-    # required by sensitivity `pip install hdim_opt[sensitivity]`
-    "pandas",
-    "SALib"
-]
-
-[project.urls]
-Repository = "https://github.com/jgsoltes/hdim_opt"
-
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["hdim_opt*"] # find hdim_opt package