```  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
```
```#![warn(missing_docs)]
#![warn(missing_doc_code_examples)]
#![warn(clippy::all)]

//! The `ka` crate provides several common ***bench***marking ***fun***ctions that are commonly
//! used to test new optimization algorithms. More specifically, the function is part of a struct
//! that contains the objective function as well as other important information. Currently a variety
//! of single-objective and multi-objective functions are implemented.

pub mod multi;
pub use multi::*;
pub mod single;
pub use single::*;

/// This is a trait that ensures consistent implementation of single objective benchmark functions
pub trait SingleObjective  {
/// The global minimum is constant and zero
const MINIMUM: f64;

/// Function for evaluating the objective function
fn f(x: Vec<f64>) -> f64;

/// This function returns the minimizer (argument that will return the global minimum)
fn minimizer(n: usize) -> Vec<f64>;

/// This function is used for testing, and checks the correctness of the minimizer
fn check_minimizer(d: usize) {
assert!(Self::f(Self::minimizer(d)) - Self::MINIMUM < f64::EPSILON)
}
}

/// This is a trait that ensures consistent implementation of multi-objective benchmark functions
pub trait MultiObjective {
/// This constant indicates the number of objectives
const NF: usize;

/// Function for evaluating the set of objective functions
fn f(x: Vec<f64>) -> Vec<f64>;
}

/// This is a trait that ensures consistent implementation of bounded benchmark functions
pub trait Bounded {
/// The bounds of the canonical optimization problem
const BOUNDS: (f64, f64);

/// Function to check bounds
fn in_bounds(x: Vec<f64>) -> bool {
let mut in_bounds = true;
for element in x {
if (element < Self::BOUNDS.0) || (element > Self::BOUNDS.1) {
in_bounds = false;
break;
}
}
in_bounds
}
}

/// This is a trait that ensures consistent implementation of unbounded benchmark functions
pub trait UnBounded {
/// The bounds of the canonical optimization problem
const BOUNDS: (f64, f64) = (f64::INFINITY, f64::INFINITY);

/// Function to check bounds
fn in_bounds(_x: Vec<f64>) -> bool {
true
}
}

/// This is a trait that ensures consistent implementation of constrained benchmark functions
pub trait Constrained {
/// This constant indicates a constrained function
const CONSTRAINED: bool = true;

/// This constant indicates the number of equality functions
const NH: usize;

/// This constant indicates the number of inequality functions
const NG: usize;

/// This function returns the value of equality constraints
fn equality_constraints(x: Vec<f64>) -> Vec<f64>;

/// This function returns the value of inequality constraints
fn inequality_constraints(x: Vec<f64>) -> Vec<f64>;

/// This is an alias for the equality constraint function
fn h(x: Vec<f64>) -> Vec<f64> {
Self::equality_constraints(x)
}

/// This is an alias for the inequality constraint function
fn g(x: Vec<f64>) -> Vec<f64> {
Self::inequality_constraints(x)
}
}

/// This is a trait that ensures consistent implementation of unconstrained benchmark functions
pub trait UnConstrained {
/// This trait indicates that the function is unconstrained
const CONSTRAINED: bool = false;
}

/// This is a trait that ensures consistent implementation of N-dimensional benchmark functions
pub trait NDimensional {
/// This is a constant containing the correct dimensionality for the function
const D: usize = usize::MAX;

/// This constant describes a low value to use for testing
const LOW_D: usize = 2;

/// This constant describes a high value to use for testing
const HIGH_D: usize = 137;
}

/// This is a trait that ensures consistent implementation of benchmark functions with fixed dimensionality
pub trait FixedDimensional {
/// This is a constant containing the correct dimensionality for the function
const D: usize;

/// This function is used to check inputs
fn check_input(x: Vec<f64>){
if x.len() != Self::D {
panic!("A vector with size {} was used with a function of dimensionality {}.", x.len(), Self::D);
}
}
}
```