cvxrust

https://docs.rs/cvxrust/0.1.0/cvxrust/
Admin
cvxrust is a Rust implementation of Disciplined Convex Programming (DCP) that provides a...
Tokens:62,323
Snippets:555
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Getting Metadata with `and_then`

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

This example demonstrates using `and_then` to chain metadata retrieval operations, which can fail. It shows how to handle both successful and unsuccessful attempts to get file metadata.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Quick Start: Least-Squares Problem in Cvxrust

Source: https://docs.rs/cvxrust

Demonstrates building and solving a least-squares problem using cvxrust. Ensure you have the necessary prelude imports and define your matrix 'a' and vector 'b'. The problem is subject to non-negativity constraints on the variable 'x'.

```rust
use cvxrust::prelude::*;

// Create variables
let x = variable(5);

// Build and solve a least-squares problem
let a = constant_dmatrix(/* your matrix */);
let b = constant_vec(/* your vector */);

let solution = Problem::minimize(sum_squares(&(&a.matmul(&x) - &b)))
    .subject_to([x.ge(constant(0.0))])
    .solve()?;

println!("Optimal value: {}", solution.value.unwrap());
```

--------------------------------

### Create CSC Identity Matrix

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/sparse/fn.csc_identity.html

Use this function to create a CSC identity matrix of a specified size. No specific setup or imports are required beyond the function itself.

```rust
pub fn csc_identity(n: usize) -> CscMatrix<f64>
```

--------------------------------

### Collect into Result<Vec<u32>, &str> - Partial Collection

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Demonstrates that collection stops at the first Err. This example shows that 'shared' only accumulates values before the underflow occurs.

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

--------------------------------

### Get Dual Variable Values with cvxrust

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Solution.html

Retrieves all dual variable values (Lagrange multipliers) for the constraints. Returns `None` if the problem was not solved. The order of duals corresponds to constraint types: equality, non-negativity, SOC, exponential, and power cones.

```rust
use cvxrust::prelude::*;

let x = variable(2);
let solution = Problem::minimize(sum(&x))
    .subject_to([x.ge(constant(1.0))])
    .solve()
    .unwrap();

if let Some(duals) = solution.duals() {
    println!("Dual values: {:?}", duals);
}
```

--------------------------------

### Usage of constraint macro

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/prelude/macro.constraint.html

Demonstrates creating constraints using the constraint! macro with variables and comparison operators.

```rust
use cvxrust::prelude::*;

let x = variable(5);
let c1 = constraint!(x >= 1.0);
let c2 = constraint!(x <= 10.0);
let c3 = constraint!(x == 5.0);
```

--------------------------------

### Build and Solve Problem with Default Settings

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.ProblemBuilder.html

Builds the optimization problem and solves it using default settings. Returns a Result containing the Solution.

```rust
pub fn solve(self) -> Result<Solution>
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/canonicalizer/struct.CanonResult.html

Gets the TypeId of self. This is a blanket implementation for any type T.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Import cvxrust prelude

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/prelude/index.html

Use this import to bring all essential cvxrust traits and types into scope.

```rust
use cvxrust::prelude::*;
```

--------------------------------

### Get Owned Type for ToOwned

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/lin_expr/struct.LinExpr.html

Specifies the owned type for the ToOwned trait implementation, which is the same as the borrowed type.

```rust
type Owned = T
```

--------------------------------

### Get LinExpr Size

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/lin_expr/struct.LinExpr.html

Retrieves the flattened output size of the linear expression. Useful for dimension checks.

```rust
pub fn size(&self) -> usize
```

--------------------------------

### Settings Struct

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Settings.html

Configuration settings for the cvxrust solver.

```APIDOC
## Struct Settings

### Description
Solver settings.

### Fields
- **verbose** (bool) - Print solver output.
- **max_iter** (u32) - Maximum iterations.
- **time_limit** (f64) - Time limit in seconds.
- **tol_gap_abs** (f64) - Absolute tolerance.
- **tol_gap_rel** (f64) - Relative tolerance.

### Request Example
```json
{
  "verbose": true,
  "max_iter": 1000,
  "time_limit": 60.0,
  "tol_gap_abs": 1e-6,
  "tol_gap_rel": 1e-5
}
```

### Response Example
```json
{
  "verbose": true,
  "max_iter": 1000,
  "time_limit": 60.0,
  "tol_gap_abs": 1e-6,
  "tol_gap_rel": 1e-5
}
```
```

--------------------------------

### Slice a range from an expression

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/atoms/affine/fn.slice.html

Use this function to obtain a sub-expression by specifying the start and stop indices. Ensure the indices are valid for the expression.

```rust
pub fn slice(expr: &Expr, start: usize, stop: usize) -> Expr
```

--------------------------------

### Construct and solve an optimization problem

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/index.html

Use the Problem builder pattern to define an objective and constraints, then solve the optimization.

```rust
let solution = Problem::minimize(objective)
    .subject_to([constraint1, constraint2])
    .solve()?;
```

--------------------------------

### Negate Sign

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/dcp/sign/enum.Sign.html

Returns the opposite sign of the current sign. For example, Nonnegative becomes Nonpositive. This method is part of the Sign enum.

```rust
pub fn negate(self) -> Self
```

--------------------------------

### Get Variable IDs from LinExpr

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/lin_expr/struct.LinExpr.html

Retrieves a list of all unique variable IDs present in the linear expression. Useful for understanding the dependencies of the expression.

```rust
pub fn variables(&self) -> Vec<ExprId>
```

--------------------------------

### into_ok()

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Nightly-only experimental API. Returns the contained Ok value, never panics. Useful as a compile-time safeguard.

```APIDOC
## into_ok()

### Description
Nightly-only experimental API. Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok`

### Endpoint
N/A (Method on Rust's Result type)

### Request Body
N/A

### Request Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

### Response
#### Success Response (Ok value)
- **T** (type) - The contained Ok value.

### Response Example
(See Request Example)
```

--------------------------------

### Cvxrust Prelude Imports

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/prelude/index.html

This snippet shows how to import all necessary items from the cvxrust prelude for convenient access to its functionalities.

```APIDOC
## Module prelude
cvxrust

### Summary
Prelude module for convenient imports.

ⓘ```rust
use cvxrust::prelude::*;
```

### Re-exports
This module re-exports the following items for easier access:

- `crate::expr::constant`
- `crate::expr::constant_dmatrix`
- `crate::expr::constant_matrix`
- `crate::expr::constant_sparse`
- `crate::expr::constant_vec`
- `crate::expr::eye`
- `crate::expr::ones`
- `crate::expr::variable`
- `crate::expr::zeros`
- `crate::expr::Array`
- `crate::expr::Expr`
- `crate::expr::ExprId`
- `crate::expr::IntoConstant`
- `crate::expr::Shape`
- `crate::expr::VariableBuilder`
- `crate::expr::VariableExt`
- `crate::atoms::abs`
- `crate::atoms::cumsum`
- `crate::atoms::diag`
- `crate::atoms::dot`
- `crate::atoms::entropy`
- `crate::atoms::exp`
- `crate::atoms::flatten`
- `crate::atoms::hstack`
- `crate::atoms::log`
- `crate::atoms::matmul`
- `crate::atoms::max2`
- `crate::atoms::maximum`
- `crate::atoms::min2`
- `crate::atoms::minimum`
- `crate::atoms::neg_part`
- `crate::atoms::norm`
- `crate::atoms::norm1`
- `crate::atoms::norm2`
- `crate::atoms::norm_inf`
- `crate::atoms::pos`
- `crate::atoms::power`
- `crate::atoms::quad_form`
- `crate::atoms::quad_over_lin`
- `crate::atoms::reshape`
- `crate::atoms::sqrt`
- `crate::atoms::sum`
- `crate::atoms::sum_axis`
- `crate::atoms::sum_squares`
- `crate::atoms::trace`
- `crate::atoms::transpose`
- `crate::atoms::try_norm`
- `crate::atoms::vstack`
- `crate::constraints::Constraint`
- `crate::constraints::ConstraintExt`
- `crate::dcp::Curvature`
- `crate::dcp::Sign`
- `crate::problem::Objective`
- `crate::problem::Problem`
- `crate::problem::ProblemBuilder`
- `crate::solver::Settings`
- `crate::solver::Solution`
- `crate::solver::SolveStatus`
- `crate::error::CvxError`
- `crate::error::Result`
```

--------------------------------

### Unsafe `unwrap_err_unchecked` on `Err` Value

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

This example shows the safe usage of `unwrap_err_unchecked` when the `Result` is known to be `Err`. Calling this on an `Ok` results in undefined behavior.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

--------------------------------

### Unsafe `unwrap_unchecked` on `Ok` Value

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

This example shows the safe usage of `unwrap_unchecked` when the `Result` is known to be `Ok`. Calling this on an `Err` results in undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

--------------------------------

### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/canonicalizer/enum.ConeConstraint.html

An experimental nightly-only API for copying data to an uninitialized memory location. Use with caution.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### VariableMap::get Implementation

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/stuffing/struct.VariableMap.html

Retrieves the column range (start column and size) for a given variable ID from the VariableMap. Returns None if the variable ID is not found.

```rust
pub fn get(&self, var_id: ExprId) -> Option<(usize, usize)>
```

--------------------------------

### Problem Constructors

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.Problem.html

Methods for creating new Problem instances.

```APIDOC
## Problem Constructors

### `minimize(expr: Expr) -> ProblemBuilder`
Create a minimization problem.

### `maximize(expr: Expr) -> ProblemBuilder`
Create a maximization problem.
```

--------------------------------

### Build and Solve Problem with Custom Settings

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.ProblemBuilder.html

Builds the optimization problem and solves it using custom settings. This allows for fine-tuning the solver.

```rust
pub fn solve_with(self, settings: Settings) -> Result<Solution>
```

--------------------------------

### Iterate Over Result Value

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Use `iter` to get an iterator that yields a reference to the contained value if the Result is `Ok`, otherwise yields nothing. This is useful for functional-style processing.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### Trait Implementations

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/struct.ExprId.html

Documentation for trait implementations within the cvxrust project.

```APIDOC
## Trait Implementations

### MaybeFaerFloatT
- **Implementation**: impl<T> MaybeFaerFloatT for T

### Scalar
- **Implementation**: impl<T> Scalar for T
- **Constraints**: T: 'static + Clone + PartialEq + Debug
```

--------------------------------

### Problem Methods

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.Problem.html

Methods for interacting with and solving optimization problems.

```APIDOC
## Problem Methods

### `is_dcp(&self) -> bool`
Check if this problem is DCP-compliant.

A problem is DCP if:
  * Minimize: objective is convex
  * Maximize: objective is concave
  * All constraints are DCP

### `variables(&self) -> Vec<ExprId>`
Get all variable IDs in this problem.

### `variable_shapes(&self) -> Vec<(ExprId, Shape)>`
Get all variables with their shapes.

### `solve(&self) -> Result<Solution>`
Solve the problem with default settings.

### `solve_with(&self, settings: Settings) -> Result<Solution>`
Solve the problem with custom settings.
```

--------------------------------

### Get Scalar Variable Value with cvxrust

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Solution.html

Retrieves the scalar value of a variable from the solution. Panics if the variable is not found or is not scalar. Use `try_value()` for error handling or the index operator for vectors/matrices.

```rust
use cvxrust::prelude::*;

let x = variable(());
let solution = Problem::minimize(x.clone())
    .subject_to([x.ge(1.0)])
    .solve()
    .unwrap();

let x_val = solution.value(&x);
```

--------------------------------

### Struct IndexSpec Definition

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/struct.IndexSpec.html

Defines the IndexSpec struct used for specifying indexing operations. It contains a vector of optional tuples, where each tuple represents a range (start, stop, step) for a dimension.

```rust
pub struct IndexSpec {
    pub ranges: Vec<Option<(usize, usize, usize)>>,
}
```

--------------------------------

### Define Solver Settings

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Settings.html

The Settings struct contains fields for configuring solver behavior and convergence criteria.

```rust
pub struct Settings {
    pub verbose: bool,
    pub max_iter: u32,
    pub time_limit: f64,
    pub tol_gap_abs: f64,
    pub tol_gap_rel: f64,
}
```

--------------------------------

### Cvxrust 0.1.0 API Documentation

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/all.html

This section details the available structs, enums, traits, macros, and functions within the cvxrust 0.1.0 library.

```APIDOC
## Cvxrust 0.1.0 API Documentation

This document outlines the structure and functionality of the cvxrust 0.1.0 library.

### Structs

- `canon::canonicalizer::CanonResult`
- `canon::lin_expr::LinExpr`
- `canon::lin_expr::QuadExpr`
- `expr::expression::ConstantData`
- `expr::expression::ExprId`
- `expr::expression::IndexSpec`
- `expr::expression::VariableData`
- `expr::shape::Shape`
- `expr::variable::VariableBuilder`
- `problem::Problem`
- `problem::ProblemBuilder`
- `solver::clarabel::Settings`
- `solver::clarabel::Solution`
- `solver::stuffing::ConeDims`
- `solver::stuffing::StuffedProblem`
- `solver::stuffing::VariableMap

### Enums

- `canon::canonicalizer::CanonExpr`
- `canon::canonicalizer::ConeConstraint`
- `constraints::constraint::Constraint`
- `dcp::curvature::Curvature`
- `dcp::curvature::PsdStatus`
- `dcp::sign::Sign`
- `error::CvxError`
- `expr::expression::Array`
- `expr::expression::Expr`
- `problem::Objective`
- `solver::clarabel::SolveStatus

### Traits

- `constraints::constraint::ConstraintExt`
- `expr::constant::IntoConstant`
- `expr::variable::VariableExt

### Macros

- `constraint`
- `prelude::constraint

### Functions

#### Affine Functions

- `atoms::affine::cumsum`
- `atoms::affine::diag`
- `atoms::affine::dot`
- `atoms::affine::flatten`
- `atoms::affine::hstack`
- `atoms::affine::index`
- `atoms::affine::matmul`
- `atoms::affine::reshape`
- `atoms::affine::slice`
- `atoms::affine::sum`
- `atoms::affine::sum_axis`
- `atoms::affine::trace`
- `atoms::affine::transpose`
- `atoms::affine::vstack

#### Nonlinear Functions

- `atoms::nonlinear::abs`
- `atoms::nonlinear::entropy`
- `atoms::nonlinear::exp`
- `atoms::nonlinear::log`
- `atoms::nonlinear::max2`
- `atoms::nonlinear::maximum`
- `atoms::nonlinear::min2`
- `atoms::nonlinear::minimum`
- `atoms::nonlinear::neg_part`
- `atoms::nonlinear::norm`
- `atoms::nonlinear::norm1`
- `atoms::nonlinear::norm2`
- `atoms::nonlinear::norm_inf`
- `atoms::nonlinear::pos`
- `atoms::nonlinear::power`
- `atoms::nonlinear::quad_form`
- `atoms::nonlinear::quad_over_lin`
- `atoms::nonlinear::sqrt`
- `atoms::nonlinear::sum_squares`
- `atoms::nonlinear::try_norm

#### Canonicalization Functions

- `canon::canonicalizer::canonicalize

#### Curvature Functions

- `dcp::curvature::add_curvature`
- `dcp::curvature::scalar_mul_curvature

#### Sign Functions

- `dcp::sign::add_sign`
- `dcp::sign::mul_sign

#### Constant Functions

- `expr::constant::const_arc`
- `expr::constant::const_vec_arc`
- `expr::constant::constant`
- `expr::constant::constant_dmatrix`
- `expr::constant::constant_matrix`
- `expr::constant::constant_sparse`
- `expr::constant::constant_vec`
- `expr::constant::eye`
- `expr::constant::ones`
- `expr::constant::zeros

#### Variable Functions

- `expr::variable::matrix_var`
- `expr::variable::named_variable`
- `expr::variable::nonneg_variable`
- `expr::variable::nonpos_variable`
- `expr::variable::scalar_var`
- `expr::variable::var`
- `expr::variable::variable`
- `expr::variable::vector_var

#### Solver Functions

- `solver::clarabel::solve`
- `solver::stuffing::stuff_problem

#### Sparse Matrix Functions

- `sparse::csc_add`
- `sparse::csc_from_triplets`
- `sparse::csc_hstack`
- `sparse::csc_identity`
- `sparse::csc_matmul`
- `sparse::csc_neg`
- `sparse::csc_repeat_rows`
- `sparse::csc_scale`
- `sparse::csc_to_dense`
- `sparse::csc_vstack`
- `sparse::dense_to_csc`
- `sparse::sparse_dense_matmul`
- `sparse::triplets_to_csc

### Type Aliases

- `error::Result`
```

--------------------------------

### Map Error Type of a Result

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Use `map_err` to transform the error type of a Result. This is useful when you need to convert an error into a different type, for example, to match an expected error signature.

```rust
fn stringify(x: u32) -> String { format!("error code: {x}") }

let x: Result<u32, u32> = Ok(2);
assert_eq!(x.map_err(stringify), Ok(2));

let x: Result<u32, u32> = Err(13);
assert_eq!(x.map_err(stringify), Err("error code: 13".to_string()));
```

--------------------------------

### Get Specific Constraint Dual Value with cvxrust

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Solution.html

Retrieves the dual value for a specific constraint by its index. The index corresponds to the order constraints were added. Returns `None` if the problem was not solved or the index is out of bounds.

```rust
use cvxrust::prelude::*;

let x = variable(2);
let solution = Problem::minimize(sum(&x))
    .subject_to([
        x.ge(constant(1.0)),  // Constraint 0
    ])
    .solve()
    .unwrap();

if let Some(dual_0) = solution.constraint_dual(0) {
    println!("Shadow price of first constraint: {}", dual_0);
}
```

--------------------------------

### clone_to_uninit

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/struct.Solution.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn`

### Endpoint
N/A (Method implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None

### Notes
This is a nightly-only experimental API.
```

--------------------------------

### Result Implementations

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Provides documentation for various implementations of the Result type, including methods for copying, cloning, transposing, flattening, and checking the status of the result.

```APIDOC
## Implementations

### impl<T, E> Result<&T, E>

#### `pub const fn copied(self) -> Result<T, E>` where T: Copy
Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.

##### Examples
```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

#### `pub fn cloned(self) -> Result<T, E>` where T: Clone
Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

##### Examples
```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

### impl<T, E> Result<&mut T, E>

#### `pub const fn copied(self) -> Result<T, E>` where T: Copy
Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.

##### Examples
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

#### `pub fn cloned(self) -> Result<T, E>` where T: Clone
Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

##### Examples
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

### impl<T, E> Result<Option<T>, E>

#### `pub const fn transpose(self) -> Option<Result<T, E>>`
Transposes a `Result` of an `Option` into an `Option` of a `Result`.
`Ok(None)` will be mapped to `None`. `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`. 

##### Examples
```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

### impl<T, E> Result<Result<T, E>, E>

#### `pub const fn flatten(self) -> Result<T, E>`
Converts from `Result<Result<T, E>, E>` to `Result<T, E>`

##### Examples
```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

Flattening only removes one level of nesting at a time:
```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

### impl<T, E> Result<T, E>

#### `pub const fn is_ok(&self) -> bool`
Returns `true` if the result is `Ok`.

##### Examples
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

#### `pub fn is_ok_and<F>(self, f: F) -> bool` where F: FnOnce(T) -> bool
Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

##### Examples
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

#### `pub const fn is_err(&self) -> bool`
Returns `true` if the result is `Err`.

##### Examples
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

#### `pub fn is_err_and<F>(self, f: F) -> bool` where F: FnOnce(E) -> bool
Returns `true` if the result is `Err` and the value inside of it matches a predicate.
```

--------------------------------

### Iterate Mutably Over Result Value

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Use `iter_mut` to get a mutable iterator that yields a mutable reference to the contained value if the Result is `Ok`, otherwise yields nothing. This allows in-place modification of the `Ok` value.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### try_into Conversion

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/lin_expr/struct.QuadExpr.html

Documentation for the try_into method used for type conversion.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from the current type to the target type U.

### Returns
- **Result<U, <U as TryFrom<T>>::Error>** - The result of the conversion, returning the converted type or an error.
```

--------------------------------

### Function: stuff_problem

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/stuffing/index.html

Builds a StuffedProblem from canonicalized components, preparing the optimization problem for the Clarabel solver.

```APIDOC
## Function: stuff_problem

### Description
Builds the stuffed problem from canonicalized components. This function generates the matrices (P, q, A, b) and cone specifications required by Clarabel.

### Parameters
- **canonicalized_components** (Object) - Required - The canonicalized problem components to be converted.

### Response
- **StuffedProblem** (Object) - Returns a StuffedProblem instance ready for the Clarabel solver.
```

--------------------------------

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/struct.IndexSpec.html

Experimental nightly-only API for performing copy-assignment to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)>
```

--------------------------------

### Constraint Creation Methods

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/constraints/constraint/enum.Constraint.html

Methods for creating different types of constraints.

```APIDOC
## Constraint Creation

### `eq(lhs: Expr, rhs: Expr) -> Self`
Create an equality constraint: lhs == rhs (with broadcasting).

### `leq(lhs: Expr, rhs: Expr) -> Self`
Create an inequality constraint: lhs <= rhs (with broadcasting).

### `geq(lhs: Expr, rhs: Expr) -> Self`
Create an inequality constraint: lhs >= rhs (with broadcasting).

### `soc(t: Expr, x: Expr) -> Self`
Create a SOC constraint: ||x||_2 <= t.
```

--------------------------------

### Constraint Construction Methods

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/constraints/constraint/enum.Constraint.html

Methods for creating various constraint types, including equality, inequality, and second-order cone constraints.

```rust
pub fn eq(lhs: Expr, rhs: Expr) -> Self
```

```rust
pub fn leq(lhs: Expr, rhs: Expr) -> Self
```

```rust
pub fn geq(lhs: Expr, rhs: Expr) -> Self
```

```rust
pub fn soc(t: Expr, x: Expr) -> Self
```

--------------------------------

### Clarabel Solver Interface

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/clarabel/index.html

Documentation for the Clarabel solver module, including structs for settings and solutions, the SolveStatus enum, and the solve function.

```APIDOC
## Clarabel Solver Module

### Description
Provides the interface to the Clarabel conic solver for solving optimization problems.

### Structs
- **Settings**: Configuration parameters for the solver.
- **Solution**: The resulting data returned by the solver after execution.

### Enums
- **SolveStatus**: Represents the final status of the solver execution (e.g., solved, infeasible, etc.).

### Functions
- **solve(problem)**: Solves the provided stuffed problem using the Clarabel solver.
```

--------------------------------

### Expression Creation Utilities

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/index.html

Overview of the core expression types and creation utilities available in the expr module.

```APIDOC
## Expression Module Overview

### Description
The `expr` module provides the foundational types and builder utilities required to construct optimization problems. It includes support for variables, constants, and shape management.

### Core Types
- **Expr**: The primary enum representing all supported expression types.
- **Shape**: Defines the dimensional structure of expressions.
- **VariableBuilder**: A builder pattern implementation for creating complex variables.

### Key Creation Functions
- **variable()**: Primary entry point for creating variables.
- **constant()**: Utility for creating constant expressions.
- **matrix_var() / vector_var() / scalar_var()**: Specialized functions for creating variables of specific dimensions.
- **zeros() / ones() / eye()**: Standard matrix/vector constant generators.
```

--------------------------------

### Create Scalar, Vector, and Matrix Variables

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/variable/fn.variable.html

Use `variable` to create symbolic variables. Pass `()` for a scalar, an integer for a vector of that size, or a tuple `(rows, cols)` for a matrix.

```rust
use cvxrust::expr::variable;

// Scalar variable
let x = variable(());

// Vector variable
let y = variable(5);
let y = variable((5,));

// Matrix variable
let z = variable((3, 4));
```

--------------------------------

### Affine Functions

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/atoms/affine/index.html

This section lists and describes the available functions that operate on affine expressions.

```APIDOC
## Functions

### cumsum
Cumulative sum along an axis.

### diag
Diagonal matrix from vector, or diagonal of matrix.

### dot
Dot product (inner product) of two vectors.

### flatten
Flatten an expression to a vector.

### hstack
Horizontal stack (column-wise concatenation).

### index
Index into an expression.

### matmul
Matrix-vector or matrix-matrix multiplication.

### reshape
Reshape an expression to a new shape.

### slice
Slice a range from an expression.

### sum
Sum of all elements, or along an axis.

### sum_axis
Sum along a specific axis.

### trace
Matrix trace.

### transpose
Transpose an expression.

### vstack
Vertical stack (row-wise concatenation).
```

--------------------------------

### Indexing Solution

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/enum.Expr.html

Allows indexing into a Solution object using an Expr to retrieve matrix/vector values.

```APIDOC
## Index<&Expr> for Solution

### Description
Allows indexing into a Solution object using an Expr to retrieve matrix/vector values.

### Methods

#### fn index(&self, var: &Expr) -> &DMatrix<f64>
Get matrix/vector value for a variable using index operator.

##### Panics
Panics if the variable is not found or is a scalar (use `.value()` for scalars).

##### Example
```
use cvxrust::prelude::*;

let x = variable(5);
let solution = Problem::minimize(sum(&x))
    .subject_to([x.ge(1.0)])
    .solve()
    .unwrap();

let x_vals = &solution[&x];
println!("x[0] = {}", x_vals[(0, 0)]);
```

### Associated Types

#### type Output = Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>
The returned type after indexing.
```

--------------------------------

### DCP Analysis Module Overview

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/dcp/index.html

Overview of the core DCP analysis functionality provided by the cvxrust library.

```APIDOC
## DCP Module Overview

### Description
The `dcp` module provides the core Disciplined Convex Programming analysis functionality, including curvature tracking and sign tracking for mathematical expressions.

### Modules
- **curvature**: Provides tools for tracking curvature (convex, concave, affine, constant).
- **sign**: Provides tools for tracking sign (non-negative, non-positive, unknown).

### Re-exports
- **Curvature**: Core type for curvature tracking.
- **Sign**: Core type for sign tracking.
- **PsdStatus**: Status tracking for positive semi-definite matrices.
- **Helper Functions**: `add_curvature`, `scalar_mul_curvature`, `add_sign`, `mul_sign`.
```

--------------------------------

### CloneFrom Implementation for ConeConstraint

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/canonicalizer/enum.ConeConstraint.html

Enables efficient copying of ConeConstraint values from a source. This is an optimization for cloning.

```rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### cvxrust::expr Module Overview

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/index.html

Provides an overview of the core expression types and data structures used in cvxrust for building mathematical expressions in the DCP framework.

```APIDOC
## Module cvxrust::expr

### Description
Core expression types for cvxrust. The `Expr` enum represents all possible expressions in the DCP framework. Expressions form an immutable DAG (directed acyclic graph) using `Arc` for sharing.

### Structs

*   **ConstantData**: Data for a constant expression.
*   **ExprId**: Unique identifier for expressions.
*   **IndexSpec**: Specification for indexing operations.
*   **VariableData**: Data for a variable expression.

### Enums

*   **Array**: Efficient array storage (dense or sparse).
*   **Expr**: The core expression type - an algebraic data type.
```

--------------------------------

### Problem Struct

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.Problem.html

Represents an optimization problem with an objective and constraints.

```APIDOC
## Struct Problem

### Description
An optimization problem.

### Fields
- **objective** (Objective) - The objective to optimize.
- **constraints** (Vec<Constraint>) - The constraints.
```

--------------------------------

### Cvxrust Constraint Macro

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/prelude/index.html

Documentation for the `constraint` macro, used for creating constraints with operator syntax.

```APIDOC
## Macros

### constraint

Macro for creating constraints with operator syntax.
```

--------------------------------

### cvxrust::prelude::constraint! Macro

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/prelude/macro.constraint.html

The constraint! macro allows for the creation of mathematical constraints using familiar operator syntax. It supports various forms of linear and non-linear constraints.

```APIDOC
## constraint! Macro

### Description
Macro for creating constraints with operator syntax.

### Method
Macro

### Endpoint
N/A (Macro)

### Parameters
This macro accepts various forms of expressions for the left-hand side (lhs) and right-hand side (rhs) of the constraint, including single variables, parenthesized expressions, and constants.

### Request Example
```rust
use cvxrust::prelude::*;

let x = variable(5);
let c1 = constraint!(x >= 1.0);
let c2 = constraint!(x <= 10.0);
let c3 = constraint!(x == 5.0);
```

### Response
This macro defines a constraint object. The exact type depends on the context and the specific constraint being defined.

#### Success Response (200)
- **Constraint Object** - Represents the defined mathematical constraint.
```

--------------------------------

### csc_vstack

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/sparse/fn.csc_vstack.html

Stacks two CSC matrices vertically.

```APIDOC
## csc_vstack

### Description
Stacks two CSC matrices vertically.

### Method
N/A (This is a function, not an API endpoint)

### Parameters
- **a** (*CscMatrix<f64>*) - Required - The first CSC matrix.
- **b** (*CscMatrix<f64>*) - Required - The second CSC matrix.

### Returns
- **CscMatrix<f64>** - The resulting CSC matrix after vertical stacking.
```

--------------------------------

### Trait Implementations

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/dcp/sign/enum.Sign.html

Overview of trait implementations for Scalar and float types.

```APIDOC
## Trait Implementations

### MaybeBlasFloatT
- **impl<T> MaybeBlasFloatT for T**

### MaybeFaerFloatT
- **impl<T> MaybeFaerFloatT for T**

### Scalar
- **impl<T> Scalar for T**
  - **Constraints**: T must satisfy 'static + Clone + PartialEq + Debug
```

--------------------------------

### Expr Methods

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/enum.Expr.html

Methods for configuring and naming expressions within the cvxrust library.

```APIDOC
## fn nonneg(self) -> Expr

### Description
Create a non-negative variable with this shape.

## fn nonpos(self) -> Expr

### Description
Create a non-positive variable with this shape.

## fn named(self, name: impl Into<String>) -> Expr

### Description
Give a name to this expression (if it’s a variable).

### Parameters
#### Request Body
- **name** (impl Into<String>) - Required - The name to assign to the expression.
```

--------------------------------

### QuadExpr Implementations

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/canon/lin_expr/struct.QuadExpr.html

Methods available for the QuadExpr struct.

```APIDOC
## impl QuadExpr

### Methods
- **from_linear(linear: LinExpr) -> Self**: Create a quadratic expression from a linear expression.
- **quadratic(var_id: ExprId, p: CscMatrix<f64>) -> Self**: Create a pure quadratic term: x’ P x for a single variable.
- **is_linear(&self) -> bool**: Check if this is purely linear (no quadratic terms).
- **add(&self, other: &QuadExpr) -> QuadExpr**: Add two quadratic expressions.
- **scale(&self, scalar: f64) -> QuadExpr**: Scale by a scalar.
- **variables(&self) -> Vec<ExprId>**: Get all variable IDs in this expression.
```

--------------------------------

### TryInto Conversion

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/dcp/sign/enum.Sign.html

Details regarding the conversion process and error handling for the TryInto trait implementation.

```APIDOC
## try_into

### Description
Performs the conversion from type T to type U.

### Parameters
- **self** - Required - The instance to be converted.

### Response
- **Result<U, <U as TryFrom<T>>::Error>** - Returns the converted type U or an error if the conversion fails.
```

--------------------------------

### Function: stuff_problem

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/stuffing/fn.stuff_problem.html

Builds a stuffed problem from canonicalized components including the objective, constraints, and variables.

```APIDOC
## POST /cvxrust/solver/stuffing/stuff_problem

### Description
Build the stuffed problem from canonicalized components.

### Method
POST

### Endpoint
/cvxrust/solver/stuffing/stuff_problem

### Parameters
#### Request Body
- **objective** (QuadExpr) - Required - The quadratic expression representing the objective function.
- **constraints** (&[ConeConstraint]) - Required - A slice of cone constraints to be applied.
- **variables** (&[(ExprId, Shape)]) - Required - A slice of tuples containing the expression ID and shape for each variable.

### Response
#### Success Response (200)
- **StuffedProblem** (Object) - The resulting stuffed problem structure.
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/struct.IndexSpec.html

Provides runtime type information for IndexSpec.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### Build Problem with ProblemBuilder

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/problem/struct.ProblemBuilder.html

Constructs the optimization problem from the builder. This method finalizes the problem definition.

```rust
pub fn build(self) -> Problem
```

--------------------------------

### Chain Result with and

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Returns the provided Result if the current one is Ok, otherwise returns the Err.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));

let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

--------------------------------

### Try Trait Implementation (Nightly)

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Experimental API for the `?` operator. Defines how Result short-circuits and propagates values.

```APIDOC
## impl<T, E> Try for Result<T, E>

### Description
Experimental API for the `?` operator. Defines how Result short-circuits and propagates values.

### Methods
#### `type Output = T`
The type of the value produced by `?` when _not_ short-circuiting.

#### `type Residual = Result<Infallible, E>`
The type of the value passed to `FromResidual::from_residual` as part of `?` when short-circuiting.

#### `fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>`
Constructs the type from its `Output` type.

#### `fn branch( self, ) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>`
Used in `?` to decide whether the operator should produce a value (because this returned `ControlFlow::Continue`) or propagate a value back to the caller (because this returned `ControlFlow::Break`).

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// This is a low-level trait implementation detail and not typically called directly.
// Its behavior is observed through the use of the `?` operator.
```

### Response
#### Success Response (200)
- **ControlFlow::Continue** (T) - When the operation succeeds.
- **ControlFlow::Break** (Result<Infallible, E>) - When the operation short-circuits due to an error.

#### Response Example
```json
// No direct JSON response, behavior is within control flow.
```
```

--------------------------------

### Solver Interface

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/solver/index.html

Provides the main interface for the Cvxrust solver, including re-exports for Clarabel solver integration and matrix stuffing utilities.

```APIDOC
## Module solver

### Description
Solver interface for cvxrust. This module provides:
  * Matrix stuffing to convert canonicalized problems to solver format
  * Clarabel solver integration

### Re-exports

`pub use self::clarabel::solve;`

`pub use self::clarabel::Settings;`

`pub use self::clarabel::Solution;`

`pub use self::clarabel::SolveStatus;`

`pub use stuffing::stuff_problem;`

`pub use stuffing::ConeDims;`

`pub use stuffing::StuffedProblem;`

`pub use stuffing::VariableMap;`

### Modules

*   **clarabel**: Clarabel solver integration.
*   **stuffing**: Matrix stuffing: converts canonicalized expressions to solver format.
```

--------------------------------

### Clone Into

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/dcp/curvature/enum.Curvature.html

The `clone_into` method allows for replacing owned data with borrowed data, typically through cloning.

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
N/A (Method within a trait implementation)

### Endpoint
N/A (Method within a trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Unwrap Result or default

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/error/type.Result.html

Returns the Ok value or the default value of the type if the result is an Err.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

--------------------------------

### Create IndexSpec to Select All Elements

Source: https://docs.rs/cvxrust/0.1.0/cvxrust/expr/expression/struct.IndexSpec.html

Use this function to create an IndexSpec that selects all elements across all dimensions.

```rust
pub fn all() -> Self>
```
Tokens:
Raw