hdim-opt 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

hdim_opt/__init__.py

@@ -7,12 +7,12 @@ Functions:
 	- 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.
+	- 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:
 
@@ -38,17 +38,17 @@ Example Usage:
 """
 
 # package version
-__version__ = "1.3.1"
-__all__ = ['quasar', 'hyperellipsoid', 'sobol', 'sensitivity', 'test_functions', 'quasar_helpers','waveform'] # 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 hyperellipsoid
-from .sobol_sampling import sobol_sample as sobol
+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/hyperellipsoid_sampling.py

@@ -1,14 +1,15 @@
-# global epslion
+# 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,7 +175,7 @@ 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,
@@ -209,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
@@ -524,7 +524,6 @@ def sample(n_samples, bounds,
 
         
         ### PCA for n_dim > 2:
-        
         if normalize:
             data_to_plot_raw = initial_samples
         else:
@@ -548,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))
         
@@ -568,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/quasar_helpers.py

@@ -1,23 +1,21 @@
 # global imports
-import pandas as pd
-from sklearn.preprocessing import StandardScaler
 import numpy as np
 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.
+        - 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) + epsilon # Add epsilon to avoid div0
+    stdev = np.std(X, axis=0) + epsilon # add epsilon to avoid div0
     X_centered = (X - mean) / stdev
     
     # eigen-decomposition of the correlation matrix
@@ -25,19 +23,18 @@ def isotropize(data):
     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
-    
+    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.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,
-        'W_zca': W_zca,
-        'W_zca_inv': eigenvectors @ np.diag(np.sqrt(eigenvalues + epsilon)) @ eigenvectors.T
+        'W_zca_inv': W_zca_inv
     }
     return data_iso, params
 
@@ -50,7 +47,7 @@ def deisotropize(data_iso, params):
     # 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/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,7 +366,6 @@ 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,
@@ -392,24 +390,24 @@ 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.
@@ -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:
@@ -529,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 #################################
@@ -654,7 +652,7 @@ def optimize(func, bounds, args=(),
         else:
             reinit_proba = 0.0
         if np.random.rand() < reinit_proba:
-            population = asym_reinit(population, current_fitnesses, bounds, reinitialization, seed, vectorized=vectorized)
+            population = asym_reinit(population, current_fitnesses, bounds, reinitialization, seed, generation, vectorized=vectorized)
 
         # clip population to bounds
         if vectorized:
@@ -664,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:
@@ -684,9 +682,9 @@ 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'Early convergence: number of generations without improvement exceeds patience ({patience}).')
+                print(f'Early convergence: patience exceeded ({patience}).')
             break
         if best_fitness <= tolerance:
             if verbose:

hdim_opt/sobol_sensitivity.py

@@ -1,126 +1,185 @@
+import numpy as np
+from scipy import stats
+
+### sensitivity analysis
 def sens_analysis(func, bounds, n_samples=2**7, 
-                  kwargs=None, param_names=None,
-                  verbose=True, log_scale=True):
+                  args=None, kwargs=None, 
+                  param_names=None, calc_second_order=True, 
+                  log_scale=False, num_to_plot=10, verbose=True):
     '''
     Objective:
-        - Perform Sobol sensitivity analysis on the vectorized objective function.
+        - 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.
-        - verbose: Boolean to display plots.
+        - 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: Full sensitivity indices and confidences.
-        - S2_matrix: Matrix of S2 relationship sensitivity indices.
+        - Si: Matrix of first- and total-order sensitivity indices and confidences.
+        - S2_matrix: Matrix of second-order interactions.
     '''
 
-    # imports
+    ### 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
         import time
     except ImportError as e:
-        raise ImportError(f'Sensitivity analysis requires dependencies: (SALib, pandas, functools).') from e
-    start_time = time.time()
+        raise ImportError(f'Sensitivity analysis requires dependencies: (SALib, pandas).') from e
     
-    # define input parameters and their ranges
+    ### 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)
-
-    # define problem
+    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
+    ### generate samples
     if verbose:
-        print(f'Generating {n_samples:,.0f} Sobol samples for sensitivity analysis.')
-    param_values = sobol_sample.sample(problem, n_samples)
+        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)
 
-    # kwargs for the objective function
-    if kwargs:
-        func = partial(func, **kwargs)
-        
-    # evaluate the samples
-    values = func(param_values) 
-    
-    # running sensitivity analysis
+    ### 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=True, print_to_console=False)
+    Si = sobol_analyze.analyze(problem, values, calc_second_order=calc_second_order, 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))
+    # 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')
-        # import
+        # 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 values
+        # sort by S1
         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)) 
+        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))
         
-        # 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, 
+        ax.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,
+        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)
-
-        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)
-        axs[0].legend()
-        
-        # 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() 
+            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.
+    '''
     
-    return Si, S2_matrix
+    # 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/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)')

{hdim_opt-1.3.1.dist-info → hdim_opt-1.3.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: hdim_opt
-Version: 1.3.1
-Summary: High-dimensional global optimization and sampling toolkit for complex and 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
@@ -42,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.
 * **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.
 
 ---

hdim_opt-1.3.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+hdim_opt/__init__.py,sha256=zu2a4O3GItOyiwUyzyTx28dXUynJIx9jexNvOEOSA2I,2022
+hdim_opt/hyperellipsoid_sampling.py,sha256=FBYRu1crm5imhbO1HD_-tbtmAPmJ6322S78aU4KPbkk,24362
+hdim_opt/quasar_helpers.py,sha256=ufGnrskwuAeM13tRtoLR6GzTFsDFDX1TxQ6pgOoQ1eI,16672
+hdim_opt/quasar_optimization.py,sha256=2Q2xdKspZjRu4awut1UUBB_KCDcW2OhbuUspNQNKX3s,32376
+hdim_opt/sobol_sensitivity.py,sha256=rZcrk7CXMO_q2kUDSmJ6yGmAjZrKpnW0E97oTOTUgyo,6811
+hdim_opt/test_functions.py,sha256=RqjKYIiwAqWplGUsH4oPHLBrVdnLRyw7f0dJX5iyJ4g,2821
+hdim_opt/waveform_analysis.py,sha256=-0WGdjxYBBfSmXcT_duumxcrdMGlKe_NXpElzpzyOro,15205
+hdim_opt-1.3.2.dist-info/METADATA,sha256=fPIPpOOBso2mjpAWztJqmffMh4wwRkd59u-V_0a0ox8,4508
+hdim_opt-1.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hdim_opt-1.3.2.dist-info/top_level.txt,sha256=1KtWo9tEfEK3GC8D43cwVsC8yVG2Kc-9pl0hhcDjw4o,9
+hdim_opt-1.3.2.dist-info/RECORD,,

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:
-        - 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.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-hdim_opt/__init__.py,sha256=qP_2iUU5q7121cfy7TyvKyCDQnyg9tF8jhjszF95KAE,2023
-hdim_opt/hyperellipsoid_sampling.py,sha256=hfmQD6bPVD7VIrZfE9faAHO9BUAHrk1fYQla5RH4vFs,24459
-hdim_opt/quasar_helpers.py,sha256=Gv5QFvx7-RfTnS89Eg7b7oVn6S5urgP7t8CwVPLMTcw,16597
-hdim_opt/quasar_optimization.py,sha256=GKvO4XFZUAZ7Gz24-OFw4odqlOwVVnPJEuBZprEVqx4,32490
-hdim_opt/sobol_sampling.py,sha256=yZl6QyPtl8WpDrclPoFbr61dVww0xnhSQqvmE2XvP8E,913
-hdim_opt/sobol_sensitivity.py,sha256=QciwOnUMxDVEf6mjH2G-HB6CLLDHxO0fqTDdb3Cykcc,4427
-hdim_opt/test_functions.py,sha256=RqjKYIiwAqWplGUsH4oPHLBrVdnLRyw7f0dJX5iyJ4g,2821
-hdim_opt/waveform_analysis.py,sha256=KFoTDvP3NXrZiw9FRTNRGFE9a6Q5f5QH38YnX1_2Aj0,15206
-hdim_opt-1.3.1.dist-info/METADATA,sha256=e8FzDUbxo-tpfZ5VJ_sf8slr2TgUKInE8_QpmTYP-ZI,4440
-hdim_opt-1.3.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-hdim_opt-1.3.1.dist-info/top_level.txt,sha256=1KtWo9tEfEK3GC8D43cwVsC8yVG2Kc-9pl0hhcDjw4o,9
-hdim_opt-1.3.1.dist-info/RECORD,,