UQPyL 2.0.10__tar.gz → 2.1.0__tar.gz

{UQPyL-2.0.10 → UQPyL-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.10
+Version: 2.1.0
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>
@@ -13,7 +13,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
 
 
 # Uncertainty Quantification Python Laboratory (UQPyL)

UQPyL-2.1.0/UQPyL/DoE/fast_sequence.py

@@ -0,0 +1,91 @@
+import numpy as np
+from typing import Union, Optional
+
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
+
+class FAST_Sequence(Sampler):
+    """
+    The sample technique for FAST (Fourier Amplitude Sensitivity Test) method.
+    
+    This class generates samples for the FAST method, which is used for sensitivity analysis
+    by decomposing the output variance into contributions from each input variable.
+    
+    Methods:
+        sample: Generate a sample for the FAST method.
+    """
+    
+    def __init__(self, M: int = 4):
+        """
+        Initialize the FAST Sequence sampler with a specified interference parameter.
+        
+        :param M: The interference parameter for the Fourier series decomposition.
+        """
+        super().__init__()
+        
+        self.M = M
+    
+    def _generate(self, nt: int, nx: int):
+        """
+        Generate a sample for the FAST method.
+        
+        :param nt: Number of sample points.
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array of samples, normalized so factor values are uniformly spaced between zero and one.
+        """
+        if nt <= 4 * self.M**2:
+            raise ValueError("The number of samples must be greater than 4 * M^2!")
+        
+        w = np.zeros(nx)
+        w[0] = np.floor((nt - 1) / (2 * self.M))
+        max_wi = np.floor(w[0] / (2 * self.M))  # Saltelli's method
+        
+        if max_wi >= nx - 1:
+            w[1:] = np.floor(np.linspace(1, max_wi, nx - 1))
+        else:
+            w[1:] = np.arange(nx - 1) % max_wi + 1
+        
+        s = (2 * np.pi / nt) * np.arange(nt)
+        
+        xInit = np.zeros((nt * nx, nx))
+        w_tmp = np.zeros(nx)
+        
+        for i in range(nx):
+            w_tmp[i] = w[0]
+            idx = list(range(i)) + list(range(i + 1, nx))
+            w_tmp[idx] = w[1:]
+            idx = range(i * nt, (i + 1) * nt)
+            phi = 2 * np.pi * np.random.rand()
+            sin_result = np.sin(w_tmp[:, None] * s + phi)
+            arsin_result = (1 / np.pi) * np.arcsin(sin_result)  # Saltelli's formula
+            xInit[idx, :] = 0.5 + arsin_result.transpose()
+        
+        return xInit
+    
+    @decoratorRescale
+    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+        """
+        Generate a sample for the FAST method.
+        
+        :param nt: Number of sample points.
+        :param nx: Input dimensions of sampled points.
+        :param problem: Problem instance to use bounds for sampling.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of FAST samples.
+        """
+        if random_seed is not None:
+            self.random_state = np.random.RandomState(random_seed)
+        else:
+            self.random_state = np.random.RandomState()
+        
+        if problem is not None and nx is not None:
+            if problem.nInput != nx:
+                raise ValueError('The input dimensions of the problem and the samples must be the same')
+        elif problem is None and nx is None:
+            raise ValueError('Either the problem or the input dimensions must be provided')
+        
+        nx = problem.nInput if problem is not None else nx
+        
+        return self._generate(nt, nx)
+    
+    

{UQPyL-2.0.10 → UQPyL-2.1.0}/UQPyL/DoE/full_fact.py

@@ -6,31 +6,33 @@ from .samplerABC import Sampler, decoratorRescale
 from ..problems import ProblemABC as Problem
 
 class FFD(Sampler):
-    '''
-    Full Factorial Design
+    """
+    Full Factorial Design (FFD) for experimental design.
     
-    Methods:
-    __call__ or sample: Generate a Latin-hypercube design
-
-    '''
+    This class generates a full factorial design, which is a systematic way to explore
+    all possible combinations of factors at different levels.
     
-    #Abandon
-    # def __call__(self, nx: int, levels: Union[np.ndarray, int, list]) -> np.ndarray:
-        
-    #     return self._generate(nx, levels)
+    Methods:
+        sample: Generate a full factorial design.
+    """
     
     def _generate(self, levels: Union[np.ndarray, int, list], nx: int):
-
+        """
+        Internal method to generate the full factorial design.
+        
+        :param levels: Levels for each input dimension. Can be an integer, list, or ndarray.
+        :param nx: Number of input dimensions.
+        :return: A 2D array of full factorial design samples.
+        """
         if isinstance(levels, int):
-            levels = [levels]*nx
+            levels = [levels] * nx
         elif isinstance(levels, np.ndarray):
             levels = levels.ravel().tolist()
         
-        if len(levels)!=nx:
+        if len(levels) != nx:
             raise ValueError('The length of levels should be equal to nx or 1')
         
         factor_levels = [np.linspace(0, 1, num=level)[:level] for level in levels]
-               
         factor_combinations = list(product(*factor_levels))
        
         H = np.array(factor_combinations)
@@ -39,30 +41,26 @@ class FFD(Sampler):
     
     @decoratorRescale
     def sample(self, levels: Union[np.ndarray, int, list], nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
-        '''
-        Parameters:
-        nx: int
-            The number of input dimensions
-        
-        levels: Union[np.ndarray, int, list]
-            The levels for each input dimension
-            
-        Returns:
-        H: 2d-array
-            An n-by-samples design matrix between zero and one.        
-        '''
+        """
+        Generate a full factorial design sample.
         
+        :param levels: Levels for each input dimension. Can be an integer, list, or ndarray.
+        :param nx: Number of input dimensions.
+        :param problem: Problem instance to use bounds for sampling.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of full factorial design samples.
+        """
         if random_seed is not None:
             self.random_state = np.random.RandomState(random_seed)
         else:
             self.random_state = np.random.RandomState()
         
         if problem is not None and nx is not None:
-            if(problem.nInput!=nx):
+            if problem.nInput != nx:
                 raise ValueError('The input dimensions of the problem and the samples must be the same')
         elif problem is None and nx is None:
             raise ValueError('Either the problem or the input dimensions must be provided')
         
-        nx=problem.nInput if problem is not None else nx
+        nx = problem.nInput if problem is not None else nx
 
         return self._generate(levels, nx)

{UQPyL-2.0.10 → UQPyL-2.1.0}/UQPyL/DoE/lhs.py

@@ -1,20 +1,24 @@
-import numpy as np
 from typing import Literal, Optional
+import numpy as np
 from scipy.spatial.distance import pdist
 
-from ..problems import ProblemABC as Problem
-
 from .samplerABC import Sampler, decoratorRescale
-
-# from ._lhs import _lhs_classic, _lhs_centered, _lhs_correlate, _lhs_maximin, _lhs_centered_maximin
-
-
+from ..problems import ProblemABC as Problem
 
 def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
-    # Generate the intervals
+    """
+    Generate a classic Latin Hypercube Sampling (LHS) design.
+    
+    :param nt: Number of samples.
+    :param nx: Number of dimensions.
+    :param random_state: Random state for reproducibility.
+    :return: A 2D array of LHS samples.
+    """
     if random_state is None:
-        random_state=np.random.RandomState()
-    cut = np.linspace(0, 1, nt + 1)    
+        random_state = np.random.RandomState()
+    
+    # Generate the intervals
+    cut = np.linspace(0, 1, nt + 1)
     
     # Fill points uniformly in each interval
     u = random_state.rand(nt, nx)
@@ -22,7 +26,7 @@ def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
     b = cut[1:nt + 1]
     rdpoints = np.zeros_like(u)
     for j in range(nx):
-        rdpoints[:, j] = u[:, j]*(b-a) + a
+        rdpoints[:, j] = u[:, j] * (b - a) + a
     
     # Make the random pairings
     H = np.zeros_like(rdpoints)
@@ -35,9 +39,16 @@ def _lhs_classic(nt: int, nx: int, random_state=None) -> np.ndarray:
 ################################################################################
 
 def _lhs_centered(nt: int, nx: int, random_state=None) -> np.ndarray:
-    
+    """
+    Generate a centered Latin Hypercube Sampling (LHS) design.
+    
+    :param nt: Number of samples.
+    :param nx: Number of dimensions.
+    :param random_state: Random state for reproducibility.
+    :return: A 2D array of centered LHS samples.
+    """
     if random_state is None:
-        random_state=np.random.RandomState()
+        random_state = np.random.RandomState()
     
     # Generate the intervals
     cut = np.linspace(0, 1, nt + 1)    
@@ -58,7 +69,15 @@ def _lhs_centered(nt: int, nx: int, random_state=None) -> np.ndarray:
 ################################################################################
 
 def _lhs_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
-    
+    """
+    Generate a maximin Latin Hypercube Sampling (LHS) design.
+    
+    :param nt: Number of samples.
+    :param nx: Number of dimensions.
+    :param iterations: Number of iterations to maximize the minimum distance.
+    :param random_state: Random state for reproducibility.
+    :return: A 2D array of maximin LHS samples.
+    """
     if random_state is None:
         random_state=np.random.RandomState()
         
@@ -77,7 +96,15 @@ def _lhs_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndar
     return H
 
 def _lhs_centered_maximin(nt: int, nx: int, iterations: int, random_state=None)-> np.ndarray:
-    
+    """
+    Generate a centered maximin Latin Hypercube Sampling (LHS) design.
+    
+    :param nt: Number of samples.
+    :param nx: Number of dimensions.
+    :param iterations: Number of iterations to maximize the minimum distance.
+    :param random_state: Random state for reproducibility.
+    :return: A 2D array of centered maximin LHS samples.
+    """
     if random_state is None:
         random_state=np.random.RandomState()
     
@@ -96,7 +123,15 @@ def _lhs_centered_maximin(nt: int, nx: int, iterations: int, random_state=None)-
 ################################################################################
 
 def _lhs_correlate(nt: int, nx: int, iterations: int, random_state=None) -> np.ndarray:
-    
+    """
+    Generate a correlation-optimized Latin Hypercube Sampling (LHS) design.
+    
+    :param nt: Number of samples.
+    :param nx: Number of dimensions.
+    :param iterations: Number of iterations to minimize correlation.
+    :param random_state: Random state for reproducibility.
+    :return: A 2D array of correlation-optimized LHS samples.
+    """
     if random_state is None:
         random_state=np.random.RandomState()
     
@@ -119,81 +154,59 @@ LHS_METHOD={'classic': _lhs_classic, 'center': _lhs_centered, 'maximin': _lhs_ma
              'center_maximin': _lhs_centered_maximin, 'correlation': _lhs_correlate}
 
 class LHS(Sampler):
-    '''
-    Latin-hypercube design
-    
-    Parameters:
-    criterion : str
-        Allowable values are "classic", "center", "maximin", "center_maximin", 
-        and "correlation". (Default: classic)
-        
-    iterations : int
-        The number of iterations in the maximin, center_maximin and correlations methods
-        (Default: 5).
-    
-    problem : problem
-        if the problem is provided, the bounds of the problem will be used to generate the samples
+    """
+    Latin-hypercube design class for generating samples.
     
     Methods:
-    __call__ or sample: Generate a Latin-hypercube design
+        sample: Generate a Latin-hypercube design
+    
             
-    '''
+    """
     def __init__(self, criterion: Criterion ='classic', iterations: int=5):
+        """
+        Initialize the LHS sampler with a specified criterion and number of iterations.
         
+        :param criterion: The LHS criterion to use.
+        :param iterations: Number of iterations for optimization methods.
+        """
         self.criterion=criterion
         self.iterations=iterations
         
         #initial random state
         super().__init__()
         
-    def _generate(self, nt: int, nx:int=None):
-        '''
-        Generate a Latin-hypercube design
+    def _generate(self, nt: int, nx: int = None):
+        """
+        Generate a Latin-hypercube design.
         
-        Parameters 
-        nt: int
-            the number of sampled points
-        nx: int
-            the input dimensions of sampled points
-            
-        Returns:
-        H: 2d-array
-            An n-by-samples design matrix that has been normalized so factor values
-            are uniformly spaced between zero and one.
-        '''
+        :param nt: Number of sampled points.
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array of LHS samples.
+        """
         
         if self.criterion not in LHS_METHOD:
             raise ValueError('The criterion must be one of {}'.format(LHS_METHOD.keys()))
         
-        Sampling_method=LHS_METHOD[self.criterion]
+        Sampling_method = LHS_METHOD[self.criterion]
         
         if self.criterion in ['maximin', 'center_maximin', 'correlation']:
-            xInit=Sampling_method(nt, nx, self.iterations, self.random_state)
+            xInit = Sampling_method(nt, nx, self.iterations, self.random_state)
         else:
-            xInit=Sampling_method(nt, nx, self.random_state)
+            xInit = Sampling_method(nt, nx, self.random_state)
         
         return xInit
     
     @decoratorRescale
-    def sample(self, nt: int, nx:int = None, problem: Problem = None, random_seed: Optional[int] = None) -> np.ndarray:
-        '''
-        Generate a Latin-hypercube design
+    def sample(self, nt: int, nx: int = None, problem: Problem = None, random_seed: Optional[int] = None) -> np.ndarray:
+        """
+        Generate a Latin-hypercube design.
         
-        Parameters 
-        nt: int
-            the number of sampled points
-            
-        nx: int
-            the input dimensions of sampled points
-            
-        random_seed: int
-            the random seed for the random number generator
-            
-        Returns:
-        H: 2d-array
-            An n-by-samples design matrix that has been normalized so factor values
-            are uniformly spaced between zero and one.
-        '''
+        :param nt: Number of sampled points.
+        :param nx: Input dimensions of sampled points.
+        :param problem: Problem instance to use bounds for sampling.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of LHS samples.
+        """
         
         if random_seed is not None:
             self.random_state = np.random.RandomState(random_seed)
@@ -201,11 +214,11 @@ class LHS(Sampler):
             self.random_state = np.random.RandomState()
         
         if problem is not None and nx is not None:
-            if(problem.nInput!=nx):
+            if problem.nInput != nx:
                 raise ValueError('The input dimensions of the problem and the samples must be the same')
         elif problem is None and nx is None:
             raise ValueError('Either the problem or the input dimensions must be provided')
         
-        nx=problem.nInput if problem is not None else nx
+        nx = problem.nInput if problem is not None else nx
         
         return self._generate(nt, nx)

UQPyL-2.1.0/UQPyL/DoE/morris_sequence.py

@@ -0,0 +1,105 @@
+import numpy as np
+from typing import Optional
+
+from .samplerABC import Sampler, decoratorRescale
+from ..problems import ProblemABC as Problem
+
+class Morris_Sequence(Sampler):
+    """
+    The sample technique for Morris analysis.
+    
+    Methods:
+        sample: Generate a sample for the Morris method.
+    
+    Examples:
+        >>> mor_seq = Morris_Sequence(numLevels=4)
+        >>> mor_seq.sample(100, 4) or mor_seq(100, 4)
+    
+    Reference:
+        [1] Max D. Morris (1991) Factorial Sampling Plans for Preliminary Computational Experiments, Technometrics, 33:2, 161-174
+    """
+    def __init__(self, numLevels: int = 4):
+        """
+        Initialize the Morris Sequence sampler with a specified number of levels.
+        
+        :param numLevels: Number of levels for the Morris method.
+        """
+        super().__init__()
+        self.numLevels = numLevels
+        
+    def _generate(self, nt: int, nx: int):
+        """
+        Generate a sample for the Morris method.
+        
+        :param nt: Number of trajectories.
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array of samples, normalized so factor values are uniformly spaced between zero and one.
+        """
+        xInit = np.zeros((nt * (nx + 1), nx))
+        
+        for i in range(nt):
+            xInit[i * (nx + 1):(i + 1) * (nx + 1), :] = self._generate_trajectory(nx)
+        
+        return xInit
+    
+    @decoratorRescale
+    def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
+        """
+        Generate a sample for the Morris method.
+        
+        :param nt: Number of trajectories.
+        :param nx: Input dimensions of sampled points.
+        :param problem: Problem instance to use bounds for sampling.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of samples.
+        """
+        if random_seed is not None:
+            self.random_state = np.random.RandomState(random_seed)
+        else:
+            self.random_state = np.random.RandomState()
+        
+        if problem is not None and nx is not None:
+            if problem.nInput != nx:
+                raise ValueError('The input dimensions of the problem and the samples must be the same')
+        elif problem is None and nx is None:
+            raise ValueError('Either the problem or the input dimensions must be provided')
+        
+        nx = problem.nInput if problem is not None else nx
+        
+        return self._generate(nt, nx)
+        
+    def _generate_trajectory(self, nx: int):
+        """
+        Generate a single trajectory for the Morris method.
+        
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array representing a single trajectory.
+        """
+        delta = self.numLevels / (2 * (self.numLevels - 1))
+        
+        B = np.tril(np.ones([nx + 1, nx], dtype=int), -1)
+        
+        # From paper[1] page 164
+        D_star = np.diag(np.random.choice([-1, 1], nx))  # Step 1
+        J = np.ones((nx + 1, nx))
+        
+        levels_grids = np.linspace(0, 1 - delta, int(self.numLevels / 2))
+        x_star = np.random.choice(levels_grids, nx).reshape(1, -1)  # Step 2
+        
+        P_star = np.zeros((nx, nx))
+        cols = np.random.choice(nx, nx, replace=False)
+        P_star[np.arange(nx), cols] = 1  # Step 3
+        
+        element_a = J[0, :] * x_star
+        element_b = P_star.T
+        element_c = np.matmul(2.0 * B, element_b)
+        element_d = np.matmul((element_c - J), D_star)
+
+        B_star = element_a + (delta / 2.0) * (element_d + J)
+    
+        return B_star
+        
+        
+        
+        
+    

{UQPyL-2.0.10 → UQPyL-2.1.0}/UQPyL/DoE/random.py

@@ -5,39 +5,50 @@ from .samplerABC import Sampler, decoratorRescale
 from ..problems import ProblemABC as Problem
 
 class Random(Sampler):
-    '''
+    """
     Random Design
     
-    Method:
-    __call__ or sample: Generate a random design
+    Methods:
+        sample: Generate a random design.
     
     Examples:
-        >>> random=RANDOM()
-        >>> random(10,10) or random.sample(10,10)
-    '''
-    def _generate(self,nt: int, nx: int):
+        >>> random = Random()
+        >>> random.sample(10, 10) or random(10, 10)
+    """
+    def _generate(self, nt: int, nx: int):
+        """
+        Generate a random sample.
         
-        H=np.random.random((nt,nx))
+        :param nt: Number of sampled points.
+        :param nx: Input dimensions of sampled points.
+        :return: A 2D array of random samples.
+        """
+        H = np.random.random((nt, nx))
         
         return H
     
     @decoratorRescale
     def sample(self, nt: int, nx: Optional[int] = None, problem: Optional[Problem] = None, random_seed: Optional[int] = None):
-        '''
-        Generate a sample with random values between zero and one 
-        '''
+        """
+        Generate a sample with random values between zero and one.
         
+        :param nt: Number of sampled points.
+        :param nx: Input dimensions of sampled points.
+        :param problem: Problem instance to use bounds for sampling.
+        :param random_seed: Random seed for reproducibility.
+        :return: A 2D array of random samples.
+        """
         if random_seed is not None:
             self.random_state = np.random.RandomState(random_seed)
         else:
             self.random_state = np.random.RandomState()
         
         if problem is not None and nx is not None:
-            if(problem.nInput!=nx):
+            if problem.nInput != nx:
                 raise ValueError('The input dimensions of the problem and the samples must be the same')
         elif problem is None and nx is None:
             raise ValueError('Either the problem or the input dimensions must be provided')
         
-        nx=problem.nInput if problem is not None else nx
+        nx = problem.nInput if problem is not None else nx
         
         return self._generate(nt, nx)