mdo-lib 0.1.0__tar.gz → 0.1.2__tar.gz

{mdo_lib-0.1.0 → mdo_lib-0.1.2}/LICENSE

@@ -1,21 +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.
+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 → mdo_lib-0.1.2}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.1
 Name: mdo-lib
-Version: 0.1.0
+Version: 0.1.2
 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
         

{mdo_lib-0.1.0 → mdo_lib-0.1.2}/README.md

@@ -1,209 +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 - 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.2/mdo/__init__.py

@@ -0,0 +1,52 @@
+"""MDO (Multi-Disciplinary Optimization) library"""
+
+__version__ = "0.1.2"
+
+try:
+    from .parameters import (
+        Constant,
+        Continuous,
+        Integer,
+        Ordinal,
+        Categorical,
+        Binary,
+        Boolean,
+        String
+    )
+except ImportError:
+    pass
+
+try:
+    from .space import Space
+except ImportError:
+    pass
+
+try:
+    from .doe import BaseDOE, FullFactorial, LatinHypercube, CentralComposite
+except ImportError:
+    pass
+
+try:
+    from .surrogate import SurrogateModel, PolynomialRegression, Kriging, RBF
+except ImportError:
+    pass
+
+try:
+    from .sensitivity import SensitivityAnalysis, SobolIndices, MorrisMethod, FAST
+except ImportError:
+    pass
+
+try:
+    from .optimization import Optimizer, GradientDescent, GeneticAlgorithm, ParticleSwarmOptimization, BayesianOptimization
+except ImportError:
+    pass
+
+try:
+    from .reliability import ReliabilityAnalysis, MonteCarlo, FORM, SORM
+except ImportError:
+    pass
+
+try:
+    from .uncertainty import UncertaintyOptimizer, RobustOptimization, ReliabilityBasedOptimization
+except ImportError:
+    pass

mdo_lib-0.1.2/mdo/constraints/__init__.py

@@ -0,0 +1,5 @@
+"""Constraints module"""
+
+from .base import Constraint
+
+__all__ = ["Constraint"]

mdo_lib-0.1.0/mdo_lib/core/constraint.py → mdo_lib-0.1.2/mdo/constraints/base.py

@@ -1,4 +1,4 @@
-"""Constraint module"""
+"""Base constraint classes"""
 
 class Constraint:
     """Constraint class for optimization problems"""
@@ -26,4 +26,4 @@ class Constraint:
         Returns:
             float: Constraint value
         """
-        raise NotImplementedError("Subclass must implement evaluate method")
+        raise NotImplementedError("Subclass must implement evaluate method")

mdo_lib-0.1.2/mdo/core/__init__.py

@@ -0,0 +1,32 @@
+"""Core module for MDO library"""
+
+from ..parameters import (
+    Variable,
+    Constant,
+    ContinuousVariable,
+    IntegerVariable,
+    DiscreteVariable,
+    BooleanVariable,
+    CategoricalVariable,
+    RandomVariable
+)
+from ..objectives import Objective
+from ..constraints import Constraint
+from .evaluator import Evaluator
+from .result import Sample, Result
+
+__all__ = [
+    "Variable",
+    "Constant",
+    "ContinuousVariable",
+    "IntegerVariable",
+    "DiscreteVariable",
+    "BooleanVariable",
+    "CategoricalVariable",
+    "RandomVariable",
+    "Objective",
+    "Constraint",
+    "Evaluator",
+    "Sample",
+    "Result",
+]

{mdo_lib-0.1.0/mdo_lib → mdo_lib-0.1.2/mdo}/doe/__init__.py

@@ -1,13 +1,13 @@
-"""DOE (Design of Experiments) module"""
-
-from .base import DOE
-from .full_factorial import FullFactorial
-from .latin_hypercube import LatinHypercube
-from .central_composite import CentralComposite
-
-__all__ = [
-    "DOE",
-    "FullFactorial",
-    "LatinHypercube",
-    "CentralComposite",
-]
+"""DOE (Design of Experiments) module"""
+
+from .base_doe import BaseDOE
+from .full_factorial import FullFactorial
+from .latin_hypercube import LatinHypercube
+from .central_composite import CentralComposite
+
+__all__ = [
+    "BaseDOE",
+    "FullFactorial",
+    "LatinHypercube",
+    "CentralComposite",
+]