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
