mdo-lib 0.1.0__tar.gz

mdo_lib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MDO Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mdo_lib-0.1.0/PKG-INFO

@@ -0,0 +1,252 @@
+Metadata-Version: 2.1
+Name: mdo-lib
+Version: 0.1.0
+Summary: Multi-Disciplinary Optimization library
+Home-page: https://github.com/yourusername/mdo-lib
+Author: Your Name
+Author-email: Your Name <your.email@example.com>
+License: MIT License
+        
+        Copyright (c) 2026 MDO Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/yourusername/mdo-lib
+Project-URL: Bug Tracker, https://github.com/yourusername/mdo-lib/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: matplotlib
+
+# MDO - Multi-Disciplinary Optimization Library
+
+MDO is a comprehensive Python library for optimization, surrogate modeling, sensitivity analysis, reliability analysis, and uncertainty optimization.
+
+## Features
+
+- **Parameter Management**: Define and manage optimization parameters with bounds and constraints
+- **Design of Experiments (DOE)**: Generate samples using various DOE methods
+- **Surrogate Modeling**: Build surrogate models for efficient function approximation
+- **Sensitivity Analysis**: Analyze the impact of parameters on objectives
+- **Optimization Algorithms**: Implement various optimization algorithms
+- **Reliability Analysis**: Assess the reliability of designs under uncertainty
+- **Uncertainty Optimization**: Optimize designs considering parameter uncertainty
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Dependencies
+
+- numpy
+- scipy
+- pandas
+- scikit-learn (for surrogate models)
+- matplotlib (for visualization)
+
+## Usage Examples
+
+### Basic Optimization
+
+```python
+from mdo import Problem, Parameter, Objective, Constraint
+from mdo.optimization import GeneticAlgorithm
+
+# Define parameters
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+# Define objective function
+def objective_function(x):
+    return (x[0] - 0.5)**2 + (x[1] - 0.5)**2
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Define constraint function
+def constraint_function(x):
+    return x[0] + x[1] - 1.0
+
+con = Constraint('g', 'inequality', upper_bound=0.0)
+con.evaluate = constraint_function
+
+# Create problem
+problem = Problem([x1, x2], [obj], [con])
+
+# Create optimizer
+optimizer = GeneticAlgorithm(problem)
+
+# Run optimization
+result = optimizer.optimize()
+
+print("Best point:", result.sample.values)
+print("Objective value:", result.objectives[0])
+```
+
+### Surrogate Modeling
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.core import Evaluator
+
+# Define parameters and objective function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+def objective_function(x):
+    return np.sin(2 * np.pi * x[0]) * np.cos(2 * np.pi * x[1])
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Create problem
+problem = Problem([x1, x2], [obj])
+
+# Generate samples
+doe = LatinHypercube(problem, n_samples=50)
+samples = doe.generate()
+
+# Evaluate samples
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Extract X and y
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+
+# Train surrogate model
+model = Kriging()
+model.fit(X, y)
+
+# Predict
+print(model.predict([[0.25, 0.25]]))
+```
+
+### Sensitivity Analysis
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.sensitivity import SobolIndices
+from mdo.core import Evaluator
+
+# Define parameters and objective function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+x3 = Parameter('x3', 0.5, bounds=[0, 1])
+
+def objective_function(x):
+    return (x[0] - 0.5)**2 + 2*(x[1] - 0.5)**2 + 3*(x[2] - 0.5)**2
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Create problem
+problem = Problem([x1, x2, x3], [obj])
+
+# Generate samples and evaluate
+doe = LatinHypercube(problem, n_samples=100)
+samples = doe.generate()
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Train surrogate model
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+model = Kriging()
+model.fit(X, y)
+
+# Perform sensitivity analysis
+sobol = SobolIndices(model, problem)
+results = sobol.analyze()
+print(results)
+```
+
+### Reliability Analysis
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.reliability import MonteCarlo
+from mdo.core import Evaluator
+
+# Define parameters and limit state function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+def limit_state_function(x):
+    return (x[0] - 0.7)**2 + (x[1] - 0.7)**2 - 0.1
+
+obj = Objective('g', 'minimize')
+obj.evaluate = limit_state_function
+
+# Create problem
+problem = Problem([x1, x2], [obj])
+
+# Generate samples and evaluate
+doe = LatinHypercube(problem, n_samples=50)
+samples = doe.generate()
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Train surrogate model
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+model = Kriging()
+model.fit(X, y)
+
+# Perform reliability analysis
+monte_carlo = MonteCarlo(problem, model, n_samples=10000)
+results = monte_carlo.analyze()
+print(results)
+```
+
+## Modules
+
+- **core**: Core functionality for parameter management, problem definition, and evaluation
+- **doe**: Design of Experiments methods
+- **surrogate**: Surrogate models for function approximation
+- **sensitivity**: Sensitivity analysis methods
+- **optimization**: Optimization algorithms
+- **reliability**: Reliability analysis methods
+- **uncertainty**: Uncertainty optimization methods
+- **utils**: Utility functions for parallel computing and visualization
+- **examples**: Usage examples
+- **tests**: Test cases
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

mdo_lib-0.1.0/README.md

@@ -0,0 +1,209 @@
+# MDO - Multi-Disciplinary Optimization Library
+
+MDO is a comprehensive Python library for optimization, surrogate modeling, sensitivity analysis, reliability analysis, and uncertainty optimization.
+
+## Features
+
+- **Parameter Management**: Define and manage optimization parameters with bounds and constraints
+- **Design of Experiments (DOE)**: Generate samples using various DOE methods
+- **Surrogate Modeling**: Build surrogate models for efficient function approximation
+- **Sensitivity Analysis**: Analyze the impact of parameters on objectives
+- **Optimization Algorithms**: Implement various optimization algorithms
+- **Reliability Analysis**: Assess the reliability of designs under uncertainty
+- **Uncertainty Optimization**: Optimize designs considering parameter uncertainty
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Dependencies
+
+- numpy
+- scipy
+- pandas
+- scikit-learn (for surrogate models)
+- matplotlib (for visualization)
+
+## Usage Examples
+
+### Basic Optimization
+
+```python
+from mdo import Problem, Parameter, Objective, Constraint
+from mdo.optimization import GeneticAlgorithm
+
+# Define parameters
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+# Define objective function
+def objective_function(x):
+    return (x[0] - 0.5)**2 + (x[1] - 0.5)**2
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Define constraint function
+def constraint_function(x):
+    return x[0] + x[1] - 1.0
+
+con = Constraint('g', 'inequality', upper_bound=0.0)
+con.evaluate = constraint_function
+
+# Create problem
+problem = Problem([x1, x2], [obj], [con])
+
+# Create optimizer
+optimizer = GeneticAlgorithm(problem)
+
+# Run optimization
+result = optimizer.optimize()
+
+print("Best point:", result.sample.values)
+print("Objective value:", result.objectives[0])
+```
+
+### Surrogate Modeling
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.core import Evaluator
+
+# Define parameters and objective function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+def objective_function(x):
+    return np.sin(2 * np.pi * x[0]) * np.cos(2 * np.pi * x[1])
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Create problem
+problem = Problem([x1, x2], [obj])
+
+# Generate samples
+doe = LatinHypercube(problem, n_samples=50)
+samples = doe.generate()
+
+# Evaluate samples
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Extract X and y
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+
+# Train surrogate model
+model = Kriging()
+model.fit(X, y)
+
+# Predict
+print(model.predict([[0.25, 0.25]]))
+```
+
+### Sensitivity Analysis
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.sensitivity import SobolIndices
+from mdo.core import Evaluator
+
+# Define parameters and objective function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+x3 = Parameter('x3', 0.5, bounds=[0, 1])
+
+def objective_function(x):
+    return (x[0] - 0.5)**2 + 2*(x[1] - 0.5)**2 + 3*(x[2] - 0.5)**2
+
+obj = Objective('f', 'minimize')
+obj.evaluate = objective_function
+
+# Create problem
+problem = Problem([x1, x2, x3], [obj])
+
+# Generate samples and evaluate
+doe = LatinHypercube(problem, n_samples=100)
+samples = doe.generate()
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Train surrogate model
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+model = Kriging()
+model.fit(X, y)
+
+# Perform sensitivity analysis
+sobol = SobolIndices(model, problem)
+results = sobol.analyze()
+print(results)
+```
+
+### Reliability Analysis
+
+```python
+from mdo import Problem, Parameter, Objective
+from mdo.doe import LatinHypercube
+from mdo.surrogate import Kriging
+from mdo.reliability import MonteCarlo
+from mdo.core import Evaluator
+
+# Define parameters and limit state function
+x1 = Parameter('x1', 0.5, bounds=[0, 1])
+x2 = Parameter('x2', 0.5, bounds=[0, 1])
+
+def limit_state_function(x):
+    return (x[0] - 0.7)**2 + (x[1] - 0.7)**2 - 0.1
+
+obj = Objective('g', 'minimize')
+obj.evaluate = limit_state_function
+
+# Create problem
+problem = Problem([x1, x2], [obj])
+
+# Generate samples and evaluate
+doe = LatinHypercube(problem, n_samples=50)
+samples = doe.generate()
+evaluator = Evaluator(problem)
+results = evaluator.evaluate(samples)
+
+# Train surrogate model
+X = [sample.values for sample in samples]
+y = [result.objectives[0] for result in results]
+model = Kriging()
+model.fit(X, y)
+
+# Perform reliability analysis
+monte_carlo = MonteCarlo(problem, model, n_samples=10000)
+results = monte_carlo.analyze()
+print(results)
+```
+
+## Modules
+
+- **core**: Core functionality for parameter management, problem definition, and evaluation
+- **doe**: Design of Experiments methods
+- **surrogate**: Surrogate models for function approximation
+- **sensitivity**: Sensitivity analysis methods
+- **optimization**: Optimization algorithms
+- **reliability**: Reliability analysis methods
+- **uncertainty**: Uncertainty optimization methods
+- **utils**: Utility functions for parallel computing and visualization
+- **examples**: Usage examples
+- **tests**: Test cases
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

mdo_lib-0.1.0/mdo_lib/__init__.py

@@ -0,0 +1,45 @@
+"""MDO (Multi-Disciplinary Optimization) library"""
+
+__version__ = "0.1.0"
+
+from .core import Problem, Parameter, Objective, Constraint, Evaluator, Sample, Result
+from .doe import DOE, FullFactorial, LatinHypercube, CentralComposite
+from .surrogate import SurrogateModel, PolynomialRegression, Kriging, RBF
+from .sensitivity import SensitivityAnalysis, SobolIndices, MorrisMethod, FAST
+from .optimization import Optimizer, GradientDescent, GeneticAlgorithm, ParticleSwarmOptimization, BayesianOptimization
+from .reliability import ReliabilityAnalysis, MonteCarlo, FORM, SORM
+from .uncertainty import UncertaintyOptimizer, RobustOptimization, ReliabilityBasedOptimization
+
+__all__ = [
+    "Problem",
+    "Parameter",
+    "Objective",
+    "Constraint",
+    "Evaluator",
+    "Sample",
+    "Result",
+    "DOE",
+    "FullFactorial",
+    "LatinHypercube",
+    "CentralComposite",
+    "SurrogateModel",
+    "PolynomialRegression",
+    "Kriging",
+    "RBF",
+    "SensitivityAnalysis",
+    "SobolIndices",
+    "MorrisMethod",
+    "FAST",
+    "Optimizer",
+    "GradientDescent",
+    "GeneticAlgorithm",
+    "ParticleSwarmOptimization",
+    "BayesianOptimization",
+    "ReliabilityAnalysis",
+    "MonteCarlo",
+    "FORM",
+    "SORM",
+    "UncertaintyOptimizer",
+    "RobustOptimization",
+    "ReliabilityBasedOptimization",
+]

mdo_lib-0.1.0/mdo_lib/core/__init__.py

@@ -0,0 +1,18 @@
+"""Core module for MDO library"""
+
+from .parameter import Parameter
+from .objective import Objective
+from .constraint import Constraint
+from .problem import Problem
+from .evaluator import Evaluator
+from .result import Sample, Result
+
+__all__ = [
+    "Parameter",
+    "Objective",
+    "Constraint",
+    "Problem",
+    "Evaluator",
+    "Sample",
+    "Result",
+]

mdo_lib-0.1.0/mdo_lib/core/constraint.py

@@ -0,0 +1,29 @@
+"""Constraint module"""
+
+class Constraint:
+    """Constraint class for optimization problems"""
+    
+    def __init__(self, name, type='inequality', upper_bound=0.0, lower_bound=None):
+        """Initialize a constraint
+        
+        Args:
+            name (str): Constraint name
+            type (str, optional): Constraint type ('inequality' or 'equality'). Defaults to 'inequality'.
+            upper_bound (float, optional): Upper bound for inequality constraint. Defaults to 0.0.
+            lower_bound (float, optional): Lower bound for equality constraint. Defaults to None.
+        """
+        self.name = name
+        self.type = type
+        self.upper_bound = upper_bound
+        self.lower_bound = lower_bound
+    
+    def evaluate(self, x):
+        """Evaluate the constraint
+        
+        Args:
+            x (list): Design variables
+            
+        Returns:
+            float: Constraint value
+        """
+        raise NotImplementedError("Subclass must implement evaluate method")

mdo_lib-0.1.0/mdo_lib/core/evaluator.py

@@ -0,0 +1,60 @@
+"""Sample evaluation module"""
+
+from concurrent.futures import ThreadPoolExecutor
+
+class Evaluator:
+    """Evaluator class for evaluating samples"""
+    
+    def __init__(self, problem, parallel=False):
+        """Initialize an evaluator
+        
+        Args:
+            problem (Problem): Problem to evaluate
+            parallel (bool, optional): Whether to evaluate in parallel. Defaults to False.
+        """
+        self.problem = problem
+        self.parallel = parallel
+    
+    def evaluate(self, samples):
+        """Evaluate samples
+        
+        Args:
+            samples (list): List of Sample objects
+            
+        Returns:
+            list: List of Result objects
+        """
+        from .result import Result
+        
+        if self.parallel:
+            with ThreadPoolExecutor() as executor:
+                results = list(executor.map(self._evaluate_sample, samples))
+        else:
+            results = [self._evaluate_sample(sample) for sample in samples]
+        
+        return results
+    
+    def _evaluate_sample(self, sample):
+        """Evaluate a single sample
+        
+        Args:
+            sample (Sample): Sample to evaluate
+            
+        Returns:
+            Result: Evaluation result
+        """
+        from .result import Result
+        
+        # Evaluate objectives
+        objectives = []
+        for obj in self.problem.objectives:
+            value = obj.evaluate(sample.values)
+            objectives.append(value)
+        
+        # Evaluate constraints
+        constraints = []
+        for con in self.problem.constraints:
+            value = con.evaluate(sample.values)
+            constraints.append(value)
+        
+        return Result(sample, objectives, constraints)

mdo_lib-0.1.0/mdo_lib/core/objective.py

@@ -0,0 +1,27 @@
+"""Objective function module"""
+
+class Objective:
+    """Objective function class for optimization problems"""
+    
+    def __init__(self, name, sense='minimize', weight=1.0):
+        """Initialize an objective function
+        
+        Args:
+            name (str): Objective name
+            sense (str, optional): Optimization sense ('minimize' or 'maximize'). Defaults to 'minimize'.
+            weight (float, optional): Objective weight. Defaults to 1.0.
+        """
+        self.name = name
+        self.sense = sense
+        self.weight = weight
+    
+    def evaluate(self, x):
+        """Evaluate the objective function
+        
+        Args:
+            x (list): Design variables
+            
+        Returns:
+            float: Objective value
+        """
+        raise NotImplementedError("Subclass must implement evaluate method")

mdo_lib-0.1.0/mdo_lib/core/parameter.py

@@ -0,0 +1,41 @@
+"""Parameter management module"""
+
+class Parameter:
+    """Parameter class for optimization problems"""
+    
+    def __init__(self, name, value, bounds=None, is_continuous=True, is_integer=False):
+        """Initialize a parameter
+        
+        Args:
+            name (str): Parameter name
+            value (float): Initial value
+            bounds (tuple, optional): (lower, upper) bounds. Defaults to None.
+            is_continuous (bool, optional): Whether the parameter is continuous. Defaults to True.
+            is_integer (bool, optional): Whether the parameter is integer. Defaults to False.
+        """
+        self.name = name
+        self.value = value
+        self.bounds = bounds
+        self.is_continuous = is_continuous
+        self.is_integer = is_integer
+    
+    def validate(self, value):
+        """Validate a parameter value
+        
+        Args:
+            value (float): Value to validate
+            
+        Returns:
+            bool: True if valid, False otherwise
+        """
+        # Check if value is within bounds
+        if self.bounds:
+            lower, upper = self.bounds
+            if value < lower or value > upper:
+                return False
+        
+        # Check if value is integer if required
+        if self.is_integer and not isinstance(value, int) and not value.is_integer():
+            return False
+        
+        return True