hdim-opt 1.2.3__tar.gz → 1.3.1__tar.gz

{hdim_opt-1.2.3 → hdim_opt-1.3.1}/PKG-INFO

@@ -1,19 +1,33 @@
 Metadata-Version: 2.4
 Name: hdim_opt
-Version: 1.2.3
-Summary: Optimization toolkit for high-dimensional, non-differentiable problems.
+Version: 1.3.1
+Summary: High-dimensional global optimization and sampling toolkit for complex and 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,HDS
+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 and HDS exploitative QMC sampler.
+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.
 
 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).
+* **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
 
@@ -52,15 +67,21 @@ pip install hdim_opt
 import hdim_opt as h
 
 # Parameter Space
-n_dimensions = 100
+n_dimensions = 30
 bounds = [(-100,100)] * n_dimensions
 n_samples = 1000
 obj_func = h.test_functions.rastrigin
+time, pulse = h.waveform_analysis.e1_waveform()
 
+# Functions
 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)
+
+signal_data = h.waveform(x=time,y=pulse)
 ```
 
 ## QUASAR Optimizer
@@ -68,7 +89,7 @@ sobol_samples = h.sobol(n_samples, bounds)
 
 * 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.2.3 → hdim_opt-1.3.1}/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 and HDS exploitative QMC sampler.
+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.
 
 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).
+* **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
 
@@ -24,15 +25,21 @@ pip install hdim_opt
 import hdim_opt as h
 
 # Parameter Space
-n_dimensions = 100
+n_dimensions = 30
 bounds = [(-100,100)] * n_dimensions
 n_samples = 1000
 obj_func = h.test_functions.rastrigin
+time, pulse = h.waveform_analysis.e1_waveform()
 
+# Functions
 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)
+
+signal_data = h.waveform(x=time,y=pulse)
 ```
 
 ## QUASAR Optimizer
@@ -40,7 +47,7 @@ sobol_samples = h.sobol(n_samples, bounds)
 
 * 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.1/hdim_opt/__init__.py

@@ -0,0 +1,54 @@
+"""
+
+# hdim-opt: High-Dimensional Optimization Toolkit
+
+Functions:
+	- quasar: QUASAR optimization for high-dimensional, non-differentiable problems.
+	- 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).
+	- waveform: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary (work in progress).
+	- isotropize: Isotropize the input matrix using zero-phase component analysis.
+
+Modules:
+	- test_functions: Contains test functions for local optimization testing.
+	- waveform_analysis: Contains pulse generation functions.
+
+Example Usage:
+
+	# Import
+	>>> import hdim_opt as h
+
+	# Parameter Space
+	>>> n_dimensions = 30
+	>>> bounds = [(-100,100)] * n_dimensions
+	>>> n_samples = 1000
+	>>> obj_func = h.test_functions.rastrigin
+	>>> time, pulse = h.waveform_analysis.e1_waveform()
+
+	# Functions
+	>>> solution, fitness = h.quasar(obj_func, bounds)
+	>>> sens_matrix = h.sensitivity(obj_func, bounds)
+
+	>>> hds_samples = h.hyperellipsoid(n_samples, bounds)
+	>>> sobol_samples = h.sobol(n_samples, bounds)
+	>>> isotropic_samples = h.isotropize(sobol_samples)
+
+	>>> signal_data = h.waveform(x=time,y=pulse)
+"""
+
+# package version
+__version__ = "1.3.1"
+__all__ = ['quasar', 'hyperellipsoid', 'sobol', 'sensitivity', 'test_functions', 'quasar_helpers','waveform'] # available for star imports
+
+# import core components
+from .quasar_optimization import optimize as quasar
+from .hyperellipsoid_sampling import sample as hyperellipsoid
+from .sobol_sampling import sobol_sample as sobol
+from .sobol_sensitivity import sens_analysis as sensitivity
+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.2.3 → hdim_opt-1.3.1}/hdim_opt/hyperellipsoid_sampling.py

@@ -1,5 +1,5 @@
 # global epslion
-epsilon = 1e-12
+epsilon = 1e-16
 
 ### misc helper functions 
 
@@ -179,6 +179,7 @@ def fit_pca_for_cluster(cluster_samples, current_origin, initial_samples_std, n_
 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:
@@ -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
@@ -472,10 +474,8 @@ def sample(n_samples, bounds,
         print('    - number of samples:', len(hds_sequence))
         print(f'    - sample generation time: {sample_generation_time:.2f}')
         print(f'    - number of hyperellipsoids: {n_hyperellipsoids}')
-        print(f'    - number of initial QMC: {n_initial_qmc}')
-        print(f'    - number of initial clusters: {n_initial_clusters}')
         if weights:
-            print(f'    - gaussian weights: {weights}')
+            print(f'    - weights: {weights}')
         
         # generate a sobol sequence for comparison
         sobol_sampler = stats.qmc.Sobol(d=n_dimensions, seed=seed+2) # offset seed to be different from initial qmc
@@ -492,10 +492,8 @@ def sample(n_samples, bounds,
         sobol_std = np.std(sobol_samples)
 
         print('\nstats:')
-        print(f'    - mean HDS: {hds_mean:.2f}')
-        print(f'    - mean comparison QMC: {sobol_mean:.2f}')
-        print(f'    - stdev HDS: {hds_std:.2f}')
-        print(f'    - stdev comparison QMC: {sobol_std:.2f}\n')
+        print(f'    - HDS mean: {hds_mean:.2f}')
+        print(f'    - HDS stdev: {hds_std:.2f}\n')
 
         # dendrogram of centroids
         if plot_dendrogram:

{hdim_opt-1.2.3 → hdim_opt-1.3.1}/hdim_opt/quasar_helpers.py

@@ -1,6 +1,55 @@
 # global imports
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
 import numpy as np
-epsilon = 1e-12
+epsilon = 1e-16
+
+def isotropize(data):
+    '''
+    Objective: 
+        - Converts data to isotropic space using Zero-Phase Component Analysis (ZCA).
+        - Maintains original feature orientation while removing correlations.
+    '''
+    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) + epsilon # Add epsilon to avoid div0
+    X_centered = (X - mean) / stdev
+    
+    # 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
+    
+    # ZCA whitening matrix: W_zca = U @ diag(1/sqrt(lambda)) @ U.T
+    # transforms data to identity covariance while minimizing rotation
+    diag_inv_sqrt = np.diag(1.0 / np.sqrt(eigenvalues + epsilon))
+    W_zca = eigenvectors @ diag_inv_sqrt @ eigenvectors.T
+    
+    # transform: y = X_centered @ W_zca.T
+    data_iso = np.dot(X_centered, W_zca.T)
+    
+    # store parameters for deisotropization
+    params = {
+        'mean': mean,
+        'stdev': stdev,
+        'W_zca': W_zca,
+        'W_zca_inv': eigenvectors @ np.diag(np.sqrt(eigenvalues + epsilon)) @ eigenvectors.T
+    }
+    return data_iso, params
+
+def deisotropize(data_iso, params):
+    '''De-isotropize data to its original parameter space via inverse ZCA.'''
+    
+    # inverse ZCA: X_centered = y @ W_zca_inv.T
+    data_centered = np.dot(data_iso, params['W_zca_inv'].T)
+    
+    # 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.2.3 → hdim_opt-1.3.1}/hdim_opt/quasar_optimization.py

@@ -32,7 +32,7 @@ def initialize_population(popsize, bounds, init, hds_weights, seed, verbose):
     
             # generate samples
             if verbose:
-                print(f'Initializing: Hyperellipsoid pop. (N={popsize}, D={n_dimensions}).')
+                print(f'Initializing: Hyperellipsoid (N={popsize}, D={n_dimensions}).')
             initial_population = hds.sample(popsize, bounds, weights=hds_weights, 
                                             seed=seed, verbose=False)
     
@@ -371,10 +371,10 @@ def asym_reinit(population, current_fitnesses, bounds, reinit_method, seed, vect
 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 +382,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].
             
@@ -413,11 +412,10 @@ def optimize(func, bounds, args=(),
             - Recommended to place constraints in objective function to use Powell.
         
         - 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 +431,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()
@@ -499,10 +499,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 +513,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
@@ -537,11 +538,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 +649,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, vectorized=vectorized)
 
         # clip population to bounds
         if vectorized:
@@ -685,9 +686,12 @@ def optimize(func, bounds, args=(),
         # patience for early convergence
         if (generation - last_improvement_gen) > patience:
             if verbose:
-                print(f'\nEarly convergence: number of generations without improvement exceeds patience ({patience}).')
+                print(f'Early convergence: number of generations without improvement exceeds patience ({patience}).')
+            break
+        if best_fitness <= tolerance:
+            if verbose:
+                print(f'Early convergence: f(x) below tolerance ({tolerance:.2e}).')
             break
-
     
     ################################# POLISH #################################
     
@@ -703,7 +707,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.2.3 → hdim_opt-1.3.1}/hdim_opt/sobol_sampling.py

@@ -4,7 +4,7 @@ import numpy as np
 def sobol_sample(n_samples, bounds, normalize=False, seed=None):
     '''
     Objective:
-        - Generate a uniform scrambled Sobol sample sequence.
+        - Generates a uniform scrambled Sobol sample sequence.
     Inputs:
         - n_samples: Number of samples to generate.
         - bounds: Range to sample over.

{hdim_opt-1.2.3 → hdim_opt-1.3.1}/hdim_opt/sobol_sensitivity.py

@@ -1,4 +1,4 @@
-def sens_analysis(func, bounds, n_samples=None, 
+def sens_analysis(func, bounds, n_samples=2**7, 
                   kwargs=None, param_names=None,
                   verbose=True, log_scale=True):
     '''
@@ -24,9 +24,10 @@ def sens_analysis(func, bounds, n_samples=None,
         from SALib.analyze import sobol as sobol_analyze
         import pandas as pd
         from functools import partial
+        import time
     except ImportError as e:
         raise ImportError(f'Sensitivity analysis requires dependencies: (SALib, pandas, functools).') from e
-    
+    start_time = time.time()
     
     # define input parameters and their ranges
     bounds = np.array(bounds)
@@ -34,10 +35,6 @@ def sens_analysis(func, bounds, n_samples=None,
     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,
@@ -68,14 +65,29 @@ def sens_analysis(func, bounds, n_samples=None,
     S2_df = S2_df.fillna(S2_df.T)
     mask = np.tril(np.ones_like(S2_df, dtype=bool))
 
+    end_time = time.time()
+    run_time = end_time - start_time
     if verbose:
+        print(f'\nRun time: {run_time:.2f}s')
         # 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)) 
         
@@ -84,35 +96,27 @@ def sens_analysis(func, bounds, n_samples=None,
         index = np.arange(n_params)
         
         # plot S1 (first order) sensitivities
-        axs[0].barh(index - bar_width/2, Si['S1'], bar_width,
-               xerr=Si['S1_conf'], 
-               label='First-order ($S_1$)',
-               # color='cornflowerblue',
-               alpha=1,
-               # ecolor='lightgray',
-               capsize=2.5)
-               # edgecolor='black')
+        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)
         
-        # plot ST (total order) sensitivities
-        axs[0].barh(index + bar_width/2, Si['ST'], bar_width,
-               xerr=Si['ST_conf'], 
-               label='Total-order ($S_T$)',
-               # color='violet', 
-               # ecolor='lightgray',
-               alpha=0.75, 
-               capsize=2.5)
-               # edgecolor='black')
+        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_xlabel('Sensitivity Index')
-        axs[0].set_ylabel('Parameter')
-        axs[0].legend(loc='upper right')
-        axs[0].grid(False)
+        
         axs[0].set_yticks(index)
-        axs[0].set_yticklabels(param_names, ha='right')
+        axs[0].set_yticklabels(names_sorted)
+        axs[0].legend()
         
-        # heatmap of second order indices
+        # 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()

hdim_opt-1.3.1/hdim_opt/waveform_analysis.py

@@ -0,0 +1,449 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy import signal
+
+# constants
+epsilon = 1e-12 # to avoid mathematical singularities
+
+# visualization parameters
+plt.rcParams['figure.facecolor'] = 'black'
+plt.rcParams['axes.facecolor'] = 'black'
+plt.rcParams['text.color'] = 'white'
+plt.rcParams['axes.labelcolor'] = 'white'
+plt.rcParams['xtick.color'] = 'white'
+plt.rcParams['ytick.color'] = 'white'
+plt.rcParams['axes.edgecolor'] = 'white'
+plt.rcParams['grid.color'] = 'white'
+plt.rcParams['lines.color'] = 'white'
+
+def apply_noise(signal, noise):
+    # adding random gaussian noise within 1% of discrete amplitudes
+    stdev = np.std(np.abs(signal))
+    signal_noisy = signal + noise * np.random.normal(loc=0, scale=stdev, size=signal.shape)
+
+    return signal_noisy
+
+def e1_waveform(peak_Vm=50e3, rise_s=5e-9, decay_s=200e-9, 
+                              sample_Hz=10e9, duration_s=1e-6, noise=0.0):
+    '''
+    Objective:
+        - Generates time-domain double exponential H-EMP E1 waveform, per MIL-STD / IEC specifications.
+        - Pulse waveform: E(t) = E0 * k * (exp(-alpha*t) - exp(-beta*t))
+
+    Inputs:
+        - E_peak_V_m: Target EMP amplitude (V/m).
+        - E_rise_time_ns: Target EMP risetime (ns).
+        - E_decay_time_ns: Target decay time of the pulse (FWHM).
+        - sampling_rate: Sampling rate of pulse (Hz).
+        - duration_ns: Duration of pulse (ns).
+        
+    Outputs:
+        - time_s: Time array of pulse (s).
+        - E_t: Electric field amplitude array at each time (V/m).
+        
+    '''
+    
+    dt_s = 1 / sample_Hz
+    time_s = np.arange(0, duration_s, dt_s)
+
+    # alpha controls the decay and broadband shape
+    # input E_decay_time_ns = desired pulse FWHM
+    alpha = np.log(2) / decay_s # derived from from FWHM = ln(2) / FWHM
+
+    # beta controls the rise time and high-frequency content
+    beta = 2.0035 / rise_s # # approximate relationship: beta ~= 2.2 / (rise_time) (in seconds^-1)
+
+    # calculate time of pulse peak for k_norm calculation
+    t_peak_s = np.log(beta / alpha) / (beta - alpha)
+
+    # 'k_norm' factor normalizes pulse peak to input E_peak_V_m (50,000 V/m)
+    denominator = (np.exp(-alpha * t_peak_s) - np.exp(-beta * t_peak_s))
+    if np.isclose(denominator, 0):
+        k_norm = peak_Vm 
+    else:
+        k_norm = peak_Vm / denominator
+
+    # generate the E1 waveform
+    E_t = k_norm * (np.exp(-alpha * time_s) - np.exp(-beta * time_s))
+    
+    # adding random gaussian noise
+    E_t = apply_noise(E_t, noise)
+    
+    return time_s, E_t
+    
+def e2_waveform(E_peak=100, tr_us=1.5, tf_ms=1.0, sample_rate=1e6, duration_s=0.01, noise=0.0):
+    '''Generates E2 H-EMP pulse waveform (lightning-like).'''
+    t = np.arange(0, duration_s, 1/sample_rate)
+    alpha = 1 / (tf_ms * 1e-3)
+    beta = 1 / (tr_us * 1e-6)
+    E_t = E_peak * 1.1 * (np.exp(-alpha * t) - np.exp(-beta * t))
+    
+    # adding random gaussian noise
+    E_t = apply_noise(E_t, noise)
+    
+    return t, E_t
+
+def e3_waveform(E_peak=40, t_peak_s=10, sample_rate=10, duration_s=500, noise=0.0):
+    '''Generates E3 H-EMP pulse waveform (geostorm-like; magnetohydrodynamic).'''
+    t = np.arange(0, duration_s, 1/sample_rate)
+    
+    # simplified IEC 61000-2-9 E3 waveform
+    E_t = E_peak * (np.exp(-t/120) - np.exp(-t/20)) 
+    
+    # adding random gaussian noise
+    E_t = apply_noise(E_t, noise)
+    
+    return t, E_t
+
+def calculate_rise_time(time_array, pulse_array):
+    '''
+    Objective:
+        - Calculates the 10%-90% rise time of a double exponential pulse waveform.
+
+    Inputs:
+        - time_array: Pulse time array (s).
+        - pulse_array: Pulse waveform array (V/m).
+
+    Outputs: 
+        - rise_time: Rise time (10%-90%) of pulse waveform (ns).
+        - t_90_percent: Time at rising 90% peak amplitude (ns).
+        - t_10_percent: Time at rising 10% amplitude (ns).
+        
+    '''
+    
+    peak_amplitude = np.max(pulse_array)
+    
+    # calculate 10% and 90% thresholds
+    threshold_10_percent = 0.1 * peak_amplitude
+    threshold_90_percent = 0.9 * peak_amplitude
+
+    # find indices where the pulse first crosses the 10% threshold (rising side)
+    idx_10 = np.where(pulse_array >= threshold_10_percent)[0]
+    if len(idx_10) == 0:
+        return None
+    idx_10_first = idx_10[0]
+
+    # find indices where the pulse first crosses the 90% threshold (rising side)
+    idx_90 = np.where(pulse_array >= threshold_90_percent)[0]
+    if len(idx_90) == 0:
+        return None
+    idx_90_first = idx_90[0]
+
+    # interpolate to find the exact time points at 10% and 90% thresholds
+    # time at 10% threshold
+    t_10_percent = time_array[idx_10_first-1] + (threshold_10_percent - pulse_array[idx_10_first-1]) * \
+                   (time_array[idx_10_first] - time_array[idx_10_first-1]) / \
+                   (pulse_array[idx_10_first] - pulse_array[idx_10_first-1])
+    
+    # time at 90% threshold
+    t_90_percent = time_array[idx_90_first-1] + (threshold_90_percent - pulse_array[idx_90_first-1]) * \
+                   (time_array[idx_90_first] - time_array[idx_90_first-1]) / \
+                   (pulse_array[idx_90_first] - pulse_array[idx_90_first-1])
+
+    # calculate risetime
+    rise_time = t_90_percent - t_10_percent
+    
+    return rise_time, t_90_percent, t_10_percent
+    
+def calculate_fwhm(time_array, pulse_array):
+    '''
+    Objective:
+        - Calculates the full width at half maximum (FWHM) of a double exponential pulse waveform.
+
+    Inputs: 
+        - time_array: Pulse time array (s).
+        - pulse_array: Pulse waveform array (V/m).
+
+    Outputs:
+        - fwhm: Full-width half-max of pulse waveform (ns).
+        - t_fwhm2: Time at rising half-max (ns).
+        - t_fwhm1: Time at decaying half-max (ns).
+        
+    '''
+    
+    # find the peak value of the pulse
+    peak_amplitude = np.max(pulse_array)
+    half_max = peak_amplitude / 2.0
+
+    # find indices where the pulse is above half_max
+    indices_above_half_max = np.where(pulse_array >= half_max)[0]
+
+    # find the first and last points where the pulse crosses half_max
+    idx1 = indices_above_half_max[0]
+    idx2 = indices_above_half_max[-1]
+
+    # first FWHM crossing point (rising side)
+    if idx1 == 0: # pulse starts above half_max
+        t_fwhm1 = time_array[idx1]
+    else:
+        # interpolate to find first time point at half_max
+        t_fwhm1 = time_array[idx1-1] + (half_max - pulse_array[idx1-1]) * \
+                  (time_array[idx1] - time_array[idx1-1]) / \
+                  (pulse_array[idx1] - pulse_array[idx1-1])
+
+    # second FWHM crossing point (decaying side)
+    if idx2 == len(pulse_array) - 1: # pulse ends above half_max
+        t_fwhm2 = time_array[idx2]
+    else:
+        # interpolate to find second time point at half_max
+        t_fwhm2 = time_array[idx2] + (half_max - pulse_array[idx2]) * \
+                  (time_array[idx2+1] - time_array[idx2]) / \
+                  (pulse_array[idx2+1] - pulse_array[idx2])
+
+    # calculate FWHM
+    fwhm = t_fwhm2 - t_fwhm1
+    
+    return fwhm, t_fwhm2, t_fwhm1
+
+def apply_shielding(f, shielding_dB, rolloff_hf=500e6, rolloff_lf=1e3):
+    '''
+    Combines complex transfer function math with real-world 
+    LF (Magnetic) and HF (Leakage) rolloff physics.
+    '''
+    # base linear gain
+    base_gain = 10**(-shielding_dB/20) 
+
+    # HF rolloff
+    h_hf = 1 / (1 + 1j * (f / rolloff_hf))
+
+    # LF rolloff
+    h_lf = 1 / (1 + (rolloff_lf / (f + 1e-12)))
+
+    # total complex shielding function
+    h_total = base_gain * h_hf * h_lf
+    
+    return h_total
+    
+def analyze_waveform(x=None, y=None, sample_rate=None, domain='time', method='complex', 
+                     tf_function=None, tf_kwargs=None, noise=0.0, verbose=True):
+    '''
+    Decomposes & analyzes the given signal waveform.
+    Outputs:
+        - df_time: DataFrame of time-domain data (N rows)
+        - df_freq: DataFrame of positive frequency-domain data (N/2+1 rows)
+        - metrics: Dictionary of scalar results
+    '''
+
+    # clean
+    x = np.array(x)
+    y = np.array(y).flatten()
+    domain = 'time' if domain.lower() in ['t', 'time'] else 'freq'
+    
+    # apply transfer function
+    if tf_function:
+        y = apply_transfer_function(x, y, tf_function, domain=domain, **(tf_kwargs or {}))
+    
+    # apply gaussian noise
+    y = apply_noise(y, noise)
+
+    # extract parameters
+    if domain == 'time':
+        n = len(y)
+        fs = 1 / (x[1] - x[0])
+        if method == 'complex':
+            y_f = np.fft.fft(y) / n
+            freqs = np.fft.fftfreq(n, 1/fs)
+        elif method == 'real':
+            y_f = np.fft.rfft(y) / n
+            freqs = np.fft.rfftfreq(n, 1/fs)
+
+        y_t, t = y, x
+    else:
+        n = len(y)
+        fs = sample_rate if sample_rate else x[len(x)//2] * 2
+        if method == 'complex':
+            y_t = np.fft.ifft(y).real * n
+        elif method == 'real':
+            y_t = np.fft.irfft(y).real * n
+        t = np.arange(0, n) / fs
+        y_f, freqs = y, x
+
+    # positive half of frequencies
+    mask = freqs >= 0
+    f_pos = freqs[mask]
+    yf_pos = y_f[mask]
+
+    # energy calculation
+    esd = (np.abs(yf_pos)**2) * (2 / fs)
+    
+    # handle DC
+    esd = (np.abs(yf_pos)**2) * (2 / fs)
+    esd[0] = esd[0] / 2  # DC only exists once
+    
+    # if real, last bin (nyquist) only exists once
+    if method == 'real' and len(esd) > 0:
+        esd[-1] = esd[-1] / 2
+        
+    df_freq = f_pos[1] - f_pos[0]
+    cumul_energy = np.cumsum(esd) * df_freq
+    total_energy = cumul_energy[-1]
+
+    # convert to dataframes:
+    # time domain
+    temporal = {
+        'time_s': t,
+        'amplitude': y_t
+    }
+
+    # frequency domain
+    spectral = {
+        'freq': f_pos,
+        'signal': yf_pos,
+        'esd': esd,
+        'energy': cumul_energy
+    }
+
+    # max gradient
+    dv_dt = np.diff(y_t) * fs
+    
+    # action integral
+    action_integral = np.trapezoid(y_t**2, t)
+    
+    # calculate rise time/decay time
+    rise_s, _, _ = calculate_rise_time(t, np.abs(y_t))
+    rise_ns = 1e9 * rise_s
+    fwhm_s, _, _ = calculate_fwhm(t, np.abs(y_t))
+    fwhm_ns = 1e9 * fwhm_s
+    
+    # scalar metrics
+    metrics = {
+        'peak_t': np.max(np.abs(y_t)),
+        'peak_f': np.max(np.abs(yf_pos)),
+        'total_energy': total_energy,
+        'action_integral': action_integral,
+        'max_dv_dt': np.max(np.abs(dv_dt)),
+        'bw_90_hz': f_pos[np.where(cumul_energy >= 0.9 * total_energy)[0][0]],
+        'center_freq_hz': np.sum(f_pos * esd) / (total_energy + 1e-12),
+        'papr_db': 10 * np.log10(np.max(y_t**2) / np.mean(y_t**2)),
+        'sample_rate': fs,
+        'rise90_ns': rise_ns,
+        'fwhm_ns': fwhm_ns,
+    }
+    
+    # plot
+    if verbose:
+        plot_diagnostic_dashboard(temporal, spectral, metrics)
+
+    return temporal, spectral, metrics
+
+def apply_transfer_function(x, y, tf_function, domain='freq', **kwargs):
+    '''
+    x: Time or frequency array.
+    y: Input signal.
+    tf_function: The transfer function.
+    domain: 'freq' or 'time'.
+    **kwargs: Arguments passed to the transfer function.
+    '''
+
+    if domain == 'freq':
+        H_f = tf_function(np.abs(x), **kwargs)
+        output = y * H_f
+    elif domain == 'time':
+        h_t = tf_function(x, **kwargs) 
+        output = np.convolve(y, h_t, mode='same')
+        output *= (x[1] - x[0]) # normalize by dt
+    else:
+        raise ValueError('Unrecognized signal domain.')
+        
+    return output
+
+def plot_diagnostic_dashboard(temporal, spectral, metrics):
+    '''
+    6-plot diagnostic dashboard:
+    Time Domain | Frequency Magnitude
+    Phase Spectrum | Energy Spectral Density (ESD)
+    Cumulative Energy | Spectrogram
+    '''
+
+    # 3 rows, 2 columns
+    fig = plt.figure(figsize=(16, 20))
+    gs = fig.add_gridspec(3, 2, hspace=0.3, wspace=0.3)
+    
+    ax_time = fig.add_subplot(gs[0, 0])
+    ax_freq = fig.add_subplot(gs[0, 1])
+    ax_phase = fig.add_subplot(gs[1, 0])
+    ax_esd  = fig.add_subplot(gs[1, 1])
+    ax_cum  = fig.add_subplot(gs[2, 0])
+    ax_spec = fig.add_subplot(gs[2, 1])
+
+    # mask for positive frequencies to ensure dimensions match
+    pos_mask = spectral['freq'] >= 0
+    f_mhz = spectral['freq'][pos_mask] / 1e6
+    mag_pos = np.abs(spectral['signal'])[pos_mask]
+
+    # time domain
+    ax_time.plot(temporal['time_s']*1e6, temporal['amplitude'], color='cyan', label=f'Peak: {metrics['peak_t']:.2f}')
+    ax_time.set_title(f'Time-Domain Signal')
+    ax_time.set_xlabel(r'Time ($\mu s$)')
+    ax_time.set_ylabel('Amplitude')
+    ax_time.legend()
+
+    # frequency domain
+    ax_freq.semilogy(f_mhz, np.abs(spectral['signal']), color='violet')
+    ax_freq.set_title('Frequency-Domain Signal')
+    ax_freq.set_xlabel('Frequency (MHz)')
+    max_f = metrics['sample_rate'] / 2e6 # limit no higher than nyquist
+    ax_freq.set_xlim(0, min(1000, max_f))
+    ax_freq.grid(alpha=0.2, which='both')
+
+    # phase spectrum
+    ax_phase.plot(f_mhz, np.angle(spectral['signal']), color='limegreen', linewidth=0.5)
+    ax_phase.set_title('Phase Spectrum')
+    ax_phase.set_xlabel('Frequency (MHz)')
+    ax_phase.set_ylabel('Phase (rad)')
+    ax_phase.set_xlim(ax_freq.get_xlim())
+
+    # energy spectral density (ESD)
+    ax_esd.semilogy(f_mhz, spectral['esd'], color='gold')
+    ax_esd.set_title('Energy Spectral Density (ESD)')
+    ax_esd.set_ylabel(r'$V^2 \cdot s / Hz$')
+    ax_esd.set_xlabel('Frequency (MHz)')
+    ax_esd.set_xlim(ax_freq.get_xlim())
+    ax_esd.set_xlim(0, min(1000, max_f))
+
+    # cumulative energy distribution
+    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')
+    ax_cum.set_title('Cumulative Energy')
+    ax_cum.set_ylabel('Normalized Energy')
+    ax_cum.set_xlabel('Frequency (MHz)')
+    ax_cum.set_xlim(ax_freq.get_xlim())
+    ax_cum.legend(fontsize='small')
+
+    # spectrogram
+    # ensure amplitude is real for spectrogram
+    sample_rate = metrics['sample_rate']
+    y_signal = np.real(temporal['amplitude'])
+    window_duration_s = 0.01*(temporal['time_s'].max() - temporal['time_s'].min())
+    nperseg = int(window_duration_s * sample_rate)
+    
+    raw_n = (1/1.15) * (window_duration_s * sample_rate)
+    
+    # powers of 2
+    if raw_n <= 1:
+        nperseg = 16 # minimum window
+    else:
+        # round to nearest power of 2
+        nperseg = int(2**np.round(np.log2(raw_n)))
+        
+        # reinforce minimum
+        nperseg = max(nperseg, 16)
+    
+    # nonoverlap always less than num per segment
+    noverlap = nperseg // 2
+    f, t_spec, Sxx = signal.spectrogram(y_signal, fs=sample_rate, window='hann', 
+                                        nperseg=nperseg, noverlap=nperseg//2)
+    
+    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.2.3 → hdim_opt-1.3.1}/hdim_opt.egg-info/PKG-INFO

@@ -1,19 +1,33 @@
 Metadata-Version: 2.4
 Name: hdim_opt
-Version: 1.2.3
-Summary: Optimization toolkit for high-dimensional, non-differentiable problems.
+Version: 1.3.1
+Summary: High-dimensional global optimization and sampling toolkit for complex and 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,HDS
+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 and HDS exploitative QMC sampler.
+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.
 
 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).
+* **waveform**: Decompose the input waveform array (handles time- and frequency-domain via FFT / IFFT) into a diagnostic summary.
 
 ---
 
@@ -52,15 +67,21 @@ pip install hdim_opt
 import hdim_opt as h
 
 # Parameter Space
-n_dimensions = 100
+n_dimensions = 30
 bounds = [(-100,100)] * n_dimensions
 n_samples = 1000
 obj_func = h.test_functions.rastrigin
+time, pulse = h.waveform_analysis.e1_waveform()
 
+# Functions
 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)
+
+signal_data = h.waveform(x=time,y=pulse)
 ```
 
 ## QUASAR Optimizer
@@ -68,7 +89,7 @@ sobol_samples = h.sobol(n_samples, bounds)
 
 * 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.2.3 → hdim_opt-1.3.1}/hdim_opt.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ 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.egg-info/PKG-INFO
 hdim_opt.egg-info/SOURCES.txt
 hdim_opt.egg-info/dependency_links.txt

hdim_opt-1.3.1/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.1" # match __version__ in __init__.py
+description = "High-dimensional global optimization and sampling toolkit for complex and 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.2.3/hdim_opt/__init__.py

@@ -1,13 +0,0 @@
-# hdim_opt/__init__.py
-
-# package version
-__version__ = "1.2.3"
-__all__ = ['quasar', 'hds', 'sobol', 'sensitivity', 'test_functions', 'quasar_helpers'] # 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 .sobol_sensitivity import sens_analysis as sensitivity
-from . import test_functions
-from . import quasar_helpers

hdim_opt-1.2.3/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.2.3" # 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", "HDS"]
-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