desdeo 1.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

desdeo/problem/testproblems/zdt_problem.py

@@ -0,0 +1,271 @@
+from desdeo.problem.schema import (
+    ExtraFunction,
+    Objective,
+    Problem,
+    Variable,
+)
+
+def zdt1(number_of_variables: int) -> Problem:
+    r"""Defines the ZDT1 test problem.
+
+    The problem has a variable number of decision variables and two objective functions to be minimized as
+    follows:
+
+    \begin{align*}
+        \min\quad f_1(\textbf{x}) &= x_1 \\
+        \min\quad f_2(\textbf{x}) &= g(\textbf{x}) \cdot h(f_1(\textbf{x}), g(\textbf{x}))\\
+        g(\textbf{x}) &= 1 + \frac{9}{n-1} \sum_{i=2}^{n} x_i \\
+        h(f_1, g) &= 1 - \sqrt{\frac{f_1}{g}}, \\
+    \end{align*}
+
+    where $f_1$ and $f_2$ are objective functions, $x_1,\dots,x_n$ are decision variable, $n$
+    is the number of decision variables,
+    and $g$ and $h$ are auxiliary functions.
+    """
+    n = number_of_variables
+
+    # function f_1
+    f1_symbol = "f_1"
+    f1_expr = "x_1"
+
+    # function g
+    g_symbol = "g"
+    g_expr_1 = f"1 + (9 / ({n} - 1))"
+    g_expr_2 = "(" + " + ".join([f"x_{i}" for i in range(2, n + 1)]) + ")"
+    g_expr = g_expr_1 + " * " + g_expr_2
+
+    # function h(f, g)
+    h_symbol = "h"
+    h_expr = f"1 - Sqrt(({f1_expr}) / ({g_expr}))"
+
+    # function f_2
+    f2_symbol = "f_2"
+    f2_expr = f"{g_symbol} * {h_symbol}"
+
+    variables = [
+        Variable(name=f"x_{i}", symbol=f"x_{i}", variable_type="real", lowerbound=0, upperbound=1, initial_value=0.5)
+        for i in range(1, n + 1)
+    ]
+
+    objectives = [
+        Objective(
+            name="f_1",
+            symbol=f1_symbol,
+            func=f1_expr,
+            maximize=False,
+            ideal=0,
+            nadir=1,
+            is_convex=True,
+            is_linear=True,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="f_2",
+            symbol=f2_symbol,
+            func=f2_expr,
+            maximize=False,
+            ideal=0,
+            nadir=1,
+            is_convex=True,
+            is_linear=False,
+            is_twice_differentiable=True,
+        ),
+    ]
+
+    extras = [
+        ExtraFunction(
+            name="g", symbol=g_symbol, func=g_expr, is_convex=True, is_linear=True, is_twice_differentiable=True
+        ),
+        ExtraFunction(
+            name="h", symbol=h_symbol, func=h_expr, is_convex=True, is_linear=False, is_twice_differentiable=True
+        ),
+    ]
+
+    return Problem(
+        name="zdt1",
+        description="The ZDT1 test problem.",
+        variables=variables,
+        objectives=objectives,
+        extra_funcs=extras,
+        is_convex=True,
+        is_linear=False,
+        is_twice_differentiable=True,
+    )
+
+
+def zdt2(n_variables: int) -> Problem:
+    r"""Defines the ZDT2 test problem.
+
+    The problem has a variable number of decision variables and two objective functions to be minimized as
+    follows:
+
+    \begin{align*}
+        \min\quad f_1(\textbf{x}) &= x_1 \\
+        \min\quad f_2(\textbf{x}) &= g(\textbf{x}) \cdot h(f_1(\textbf{x}), g(\textbf{x}))\\
+        g(\textbf{x}) &= 1 + \frac{9}{n-1} \sum_{i=2}^{n} x_i \\
+        h(f_1, g) &= 1 - \left({\frac{f_1}{g}}\right)^2, \\
+    \end{align*}
+
+    where $f_1$ and $f_2$ are objective functions, $x_1,\dots,x_n$ are decision variable, $n$
+    is the number of decision variables,
+    and $g$ and $h$ are auxiliary functions.
+    """
+    n = n_variables
+
+    # function f_1
+    f1_symbol = "f_1"
+    f1_expr = "x_1"
+
+    # function g
+    g_symbol = "g"
+    g_expr_1 = f"1 + (9 / ({n} - 1))"
+    g_expr_2 = "(" + " + ".join([f"x_{i}" for i in range(2, n + 1)]) + ")"
+    g_expr = g_expr_1 + " * " + g_expr_2
+
+    # function h(f, g)
+    h_symbol = "h"
+    h_expr = f"1 - (({f1_expr}) / ({g_expr})) ** 2"
+
+    # function f_2
+    f2_symbol = "f_2"
+    f2_expr = f"{g_symbol} * {h_symbol}"
+
+    variables = [
+        Variable(name=f"x_{i}", symbol=f"x_{i}", variable_type="real", lowerbound=0, upperbound=1, initial_value=0.5)
+        for i in range(1, n + 1)
+    ]
+
+    objectives = [
+        Objective(
+            name="f_1",
+            symbol=f1_symbol,
+            func=f1_expr,
+            maximize=False,
+            ideal=0,
+            nadir=1,
+            is_convex=True,
+            is_linear=True,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="f_2",
+            symbol=f2_symbol,
+            func=f2_expr,
+            maximize=False,
+            ideal=0,
+            nadir=1,
+            is_convex=False,
+            is_linear=False,
+            is_twice_differentiable=True,
+        ),
+    ]
+
+    extras = [
+        ExtraFunction(
+            name="g", symbol=g_symbol, func=g_expr, is_convex=True, is_linear=True, is_twice_differentiable=True
+        ),
+        ExtraFunction(
+            name="h", symbol=h_symbol, func=h_expr, is_convex=False, is_linear=False, is_twice_differentiable=True
+        ),
+    ]
+
+    return Problem(
+        name="zdt2",
+        description="The ZDT2 test problem.",
+        variables=variables,
+        objectives=objectives,
+        extra_funcs=extras,
+        is_convex=False,
+        is_linear=False,
+        is_twice_differentiable=True,
+    )
+
+
+def zdt3(
+    n_variables: int,
+) -> Problem:
+    r"""Defines the ZDT3 test problem.
+
+    The problem has a variable number of decision variables and two objective functions to be minimized as
+    follows:
+
+    \begin{align*}
+        \min\quad f_1(x) &= x_1 \\
+        \min\quad f_2(x) &= g(\textbf{x}) \cdot h(f_1(\textbf{x}), g(\textbf{x}))\\
+        g(\textbf{x}) &= 1 + \frac{9}{n-1} \sum_{i=2}^{n} x_i \\
+         h(f_1, g) &= 1 - \sqrt{\frac{f_1}{g}} - \frac{f_1}{g} \sin(10\pi f_1)), \\
+    \end{align*}
+
+    where $f_2$ and $f_2$ are objective functions, $x_1,\dots,x_n$ are decision variable, $n$
+    is the number of decision variables,
+    and $g$ and $h$ are auxiliary functions.
+    """
+    n = n_variables
+
+    # function f_1
+    f1_symbol = "f_1"
+    f1_expr = "x_1"
+
+    # function g
+    g_symbol = "g"
+    g_expr_1 = f"1 + (9 / ({n} - 1))"
+    g_expr_2 = "(" + " + ".join([f"x_{i}" for i in range(2, n + 1)]) + ")"
+    g_expr = g_expr_1 + " * " + g_expr_2
+
+    # function h(f, g)
+    h_symbol = "h"
+    h_expr = f"1 - Sqrt(({f1_expr}) / ({g_expr})) - (({f1_expr}) / ({g_expr})) * Sin (10 * {np.pi} * {f1_expr}) "
+
+    # function f_2
+    f2_symbol = "f_2"
+    f2_expr = f"{g_symbol} * {h_symbol}"
+
+    variables = [
+        Variable(name=f"x_{i}", symbol=f"x_{i}", variable_type="real", lowerbound=0, upperbound=1, initial_value=0.5)
+        for i in range(1, n + 1)
+    ]
+
+    objectives = [
+        Objective(
+            name="f_1",
+            symbol=f1_symbol,
+            func=f1_expr,
+            maximize=False,
+            ideal=0,
+            nadir=1,
+            is_convex=True,
+            is_linear=True,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="f_2",
+            symbol=f2_symbol,
+            func=f2_expr,
+            maximize=False,
+            ideal=-1,
+            nadir=1,
+            is_convex=False,
+            is_linear=False,
+            is_twice_differentiable=True,
+        ),
+    ]
+
+    extras = [
+        ExtraFunction(
+            name="g", symbol=g_symbol, func=g_expr, is_convex=True, is_linear=True, is_twice_differentiable=True
+        ),
+        ExtraFunction(
+            name="h", symbol=h_symbol, func=h_expr, is_convex=False, is_linear=False, is_twice_differentiable=True
+        ),
+    ]
+
+    return Problem(
+        name="zdt3",
+        description="The ZDT3 test problem.",
+        variables=variables,
+        objectives=objectives,
+        extra_funcs=extras,
+        is_convex=False,
+        is_linear=False,
+        is_twice_differentiable=True,
+    )

desdeo/problem/utils.py

@@ -0,0 +1,245 @@
+"""Various utilities used across the framework related to the Problem formulation."""
+
+import itertools
+import warnings
+from functools import reduce
+
+import numpy as np
+import polars as pl
+
+from desdeo.problem import Problem, TensorConstant, TensorVariable, Variable
+
+
+class ProblemUtilsError(Exception):
+    """Raised when an exception occurs in one of the utils function.
+
+    Raised when an exception occurs in one of the utils functions defined in the Problem module.
+    """
+
+
+def objective_dict_to_numpy_array(problem: Problem, objective_dict: dict[str, float]) -> np.ndarray:
+    """Takes a dict with an objective vector and returns a numpy array.
+
+    Takes a dict with the keys being objective function symbols and the values
+    being the corresponding objective function values. Returns a numpy array
+    with the objective function values in the same order they have been defined
+    in the original problem.
+
+    Args:
+        problem (Problem): the problem the objective dict belongs to.
+        objective_dict (dict[str, float]): the dict with the objective function values.
+
+    Returns:
+        np.ndarray: a numpy array with the objective function values in the order they are
+            present in problem.
+    """
+    if isinstance(objective_dict[problem.objectives[0].symbol], list):
+        if len(objective_dict[problem.objectives[0].symbol]) != 1:
+            raise ValueError("The objective_dict has multiple values for an objective function")
+        return np.array([objective_dict[objective.symbol][0] for objective in problem.objectives])
+    return np.array([objective_dict[objective.symbol] for objective in problem.objectives])
+
+
+def numpy_array_to_objective_dict(problem: Problem, numpy_array: np.ndarray) -> dict[str, float]:
+    """Takes a numpy array with objective function values and return a dict.
+
+    The reverse of objective_dict_to_numpy_array.
+
+    Args:
+        problem (Problem): the problem the numpy array represents an objective vector of.
+        numpy_array (np.ndarray): the objective vector as a numpy array. The
+            array is squeezed, i.e., axes or length one are removed: [[42]] -> [42].
+
+    Returns:
+        dict[str, float]: a dict with keys being objective function symbols and value being
+            objective function values.
+    """
+    return {objective.symbol: np.squeeze(numpy_array).tolist()[i] for i, objective in enumerate(problem.objectives)}
+
+
+def unflatten_variable_array(problem: Problem, var_array: np.ndarray) -> dict[str, float | list]:
+    """Unflatten a numpy array representing decision variable values.
+
+    Unflatten a numpy array that represent decision variable values. It is assumed
+    that the unflattened values follow a C-like order when it comes to unflattening
+    values for `TensorVariable`s. Note that `var_array` must be of dimension 1.
+
+    Args:
+        problem (Problem): the problem instance the decision variables are associated with.
+        var_array (np.ndarray): a flat 1D array of numerical values representing
+            decision variable values.
+
+    Raises:
+        ValueError: `var_array` is of some other dimension that 1.
+        IndexError: `var_array` has too few elements given the variables defined in
+            the instance of `Problem`.
+        TypeError: unsupported variable type encountered in the variables defined in the
+            instance of `Problem`.
+
+    Returns:
+        dict[str, float | list]: a dict with keys equal to the symbols of the variables
+            defined in the `Problem` instance, and values equal to the decision variable
+            values as they were defined in `var_array`.
+    """
+    if (dimension := var_array.ndim) != 1:
+        msg = f"The given variable array must have a dimension of 1. Current {dimension=}"
+        raise ValueError(msg)
+
+    var_dict = {}
+    array_i = 0
+    for var in problem.variables:
+        if array_i >= len(var_array):
+            msg = (
+                "End of variable array reached before all variables in the problem were iterated over. "
+                f"The variable array is too short with length={len(var_array)}."
+            )
+            raise IndexError(msg)
+
+        if isinstance(var, Variable):
+            # regular variable, just pick it
+            var_dict[var.symbol] = var_array[array_i].item()
+            array_i += 1
+            continue
+
+        if isinstance(var, TensorVariable):
+            # tensor variable, pick row-wise from var_array
+            slice_length = reduce(lambda x1, x2: x1 * x2, var.shape)  # product of dimensions
+            flat_values = var_array[array_i : array_i + slice_length]
+            var_dict[var.symbol] = np.reshape(flat_values, var.shape, order="C").tolist()
+            array_i += slice_length
+            continue
+
+        msg = f"Unsupported variable type {type(var)} encountered."
+        raise TypeError(msg)
+
+    # check if values remain in var_array
+    if array_i < len(var_array):
+        # some values remain, warn user, but do not raise an error
+        msg = f"Warning, the variable array had some values that were not unflattened: f{["...", *var_array[array_i:]]}"
+        warnings.warn(msg, stacklevel=2)
+
+    # return the variable dict
+    return var_dict
+
+
+def flatten_variable_dict(problem: Problem, variable_dict: dict[str, float | list]) -> np.ndarray:
+    """Flatten a dictionary representing variable values of an instance of `Problem` into a numpy array.
+
+    Flattens a dictionary representing variable values of an instance of `Problem` into a numpy array.
+    The flattening follows a C-like order. Support the flattening of both `Variable` and `TensorVariable`
+    types. Note that it is assumed that no more than one value is defined for each symbol in `variable_dict`
+    that correspond to the required shape of the underlying variable type.
+
+    Args:
+        problem (Problem): the problem instance the decision variables are associated with.
+        variable_dict (dict[str, float  |  list]): a dictionary with its keys being the symbols
+            of the variables defined in the instance of `Problem`, and the values corresponding
+            to the variables' values.
+
+    Raises:
+        ValueError: the `variable_dict` does not contain as its keys one or more of the symbols
+            defined for the variables in the instance of `Problem`.
+        TypeError: unsupported variable type encountered in the variables defined in the
+            instance of `Problem`.
+
+    Returns:
+        np.ndarray: a 1D numpy array with the variable values unflattened in C-like order.
+    """
+    tmp = []
+    for var in problem.variables:
+        if isinstance(var, Variable):
+            # just a regular variable
+            if var.symbol not in variable_dict:
+                msg = f"The variable_dict is missing values for the variable {var.symbol}."
+                raise ValueError(msg)
+            tmp.append([variable_dict[var.symbol]])
+            continue
+
+        if isinstance(var, TensorVariable):
+            # tensor variable
+            if var.symbol in variable_dict:
+                # tensor variable is defined in the dict as a tensor
+                tmp = [*tmp, np.array(variable_dict[var.symbol]).flatten(order="C")]
+                continue
+            if any(key.startswith(f"{var.symbol}_") for key in variable_dict):
+                # tensor variable flattened in the dict
+                indices = itertools.product(*[range(1, s + 1) for s in var.shape])
+                flat_symbols = [f"{var.symbol}_{'_'.join(map(str, index))}" for index in indices]
+                tmp = [*tmp, np.array([variable_dict[s] for s in flat_symbols])]
+                continue
+
+            msg = f"The variable dict is missing values for the variable {var.symbol}."
+            raise ValueError(msg)
+
+        msg = f"Unsupported variable type {type(var)} encountered."
+        raise TypeError(msg)
+
+    return np.concatenate(tmp)
+
+
+def get_nadir_dict(problem: Problem) -> dict[str, float]:
+    """Return a dict representing a problem's nadir point.
+
+    Args:
+        problem (Problem): the problem with the nadir point.
+
+    Returns:
+        dict[str, float]: key are objective funciton symbols, values are nadir values.
+    """
+    return {objective.symbol: objective.nadir for objective in problem.objectives}
+
+
+def get_ideal_dict(problem: Problem) -> dict[str, float]:
+    """Return a dict representing a problem's ideal point.
+
+    Args:
+        problem (Problem): the problem with the ideal point.
+
+    Returns:
+        dict[str, float]: key are objective funciton symbols, values are ideal values.
+    """
+    return {objective.symbol: objective.ideal for objective in problem.objectives}
+
+
+def tensor_constant_from_dataframe(
+    df: pl.DataFrame, name: str, symbol: str, n_rows: int, column_names: list[str]
+) -> TensorConstant:
+    """Create a TensorConstant from a Polars dataframe.
+
+    Args:
+        df (pl.DataFrame): a Polars dataframe with at least the columns in `column_names`
+        name (str): name attribute of the created TensorConstant.
+        symbol (str): symbol attribute of the created TensorConstant.
+        n_rows (int): the number of rows to read from the dataframe.
+        column_names (list[str]): the column names in the dataframe from which
+            the constant values will be picked.
+
+    Returns:
+        TensorConstant: A TensorConstant instance with values taken from the a given
+            Polars dataframe. The shape of the TensorConstant will be
+            (`n_rows`, len(`column_names`)).
+
+    Note:
+        In the argument `shape` the first element must be either less or equal to the
+            number of rows in `df`. The second element in `shape` must be equal
+            to the number of element in `column_names`.
+    """
+    if n_rows > df.shape[0]:
+        # not enough rows in df
+        msg = f"Requested {n_rows} rows, but the dataframe has only {df.shape[0]} rows."
+        raise ProblemUtilsError(msg)
+
+    if len(column_names) > df.shape[1]:
+        # not enough cols in df
+        msg = f"Requested {len(column_names)} columns, but the dataframe has only {df.shape[1]} columns."
+        raise ProblemUtilsError(msg)
+
+    for col in column_names:
+        if col not in df.columns:
+            msg = f"The requested column '{col}' is not found in the given dataframe with columns {df.columns}."
+            raise ProblemUtilsError(msg)
+
+    selected_df = df.select(column_names).head(n_rows)
+    selected_values = [selected_df.to_dict()[col_name].to_list() for col_name in column_names]
+
+    return TensorConstant(name=name, symbol=symbol, shape=[n_rows, len(column_names)], values=selected_values)

desdeo/tools/GenerateReferencePoints.py

@@ -0,0 +1,181 @@
+"""Generate reference points for the IPA algorithm."""
+
+from itertools import product
+
+import numpy as np
+from numba import njit
+from scipy.spatial import ConvexHull
+
+
+def normalize(vectors):
+    """Normalize a set of vectors.
+
+    The length of the returned vectors will be 1.
+
+    Parameters
+    ----------
+    vectors : np.ndarray
+        Set of vectors of any length, except zero.
+
+    """
+    if len(np.asarray(vectors).shape) == 1:
+        return vectors / np.linalg.norm(vectors)
+    norm = np.linalg.norm(vectors, axis=1)
+    return vectors / norm[:, np.newaxis]
+
+
+def householder(vector):
+    """Return reflection matrix via householder transformation."""
+    identity_mat = np.eye(len(vector))
+    v = vector[np.newaxis]
+    denominator = np.matmul(v, v.T)
+    numerator = np.matmul(v.T, v)
+    rot_mat = identity_mat - (2 * numerator / denominator)
+    return rot_mat
+
+
+def rotate(initial_vector, rotated_vector, other_vectors):
+    """Calculate the rotation matrix that rotates the initial_vector to the
+    rotated_vector. Apply that rotation on other_vectors and return.
+    Uses Householder reflections twice to achieve this."""
+
+    init_vec_norm = normalize(initial_vector)
+    rot_vec_norm = normalize(np.asarray(rotated_vector))
+    middle_vec_norm = normalize(init_vec_norm + rot_vec_norm)
+    first_reflector = init_vec_norm - middle_vec_norm
+    second_reflector = middle_vec_norm - rot_vec_norm
+    Q1 = householder(first_reflector)
+    Q2 = householder(second_reflector)
+    reflection_matrix = np.matmul(Q2, Q1)
+    rotated_vectors = np.matmul(other_vectors, np.transpose(reflection_matrix))
+    return rotated_vectors
+
+
+def get_reference_hull(num_dims):
+    """Get the convex hull of the valid reference points for IPA.
+
+    This algorithm generates the vertices of the unit hypercube in the (num_dims)-dimensional space.
+    Then, the vertices are projected onto the plane perpendicular to the largest space diagonal (vertex first parallel
+    projection) and rotated such that the plane is perpendular to one of the axes. Then, the points are are flattened
+    to (num_dims-1)-dimensional space. A convex hull is then constructed from the projected vertices, and a bounding box
+    is constructed around the convex hull.
+
+    Args:
+        num_dims (int): The number of dimensions of the space in which the reference points are generated.
+
+    Returns:
+        np.ndarray: A (2) x (num_dims-1) array of the bounding box. Reference points are guaranteed to be within
+            this box. However, not all points within this box are valid reference points.
+        np.ndarray: A (num_dims-1) x (num_dims-1) array of the coefficients of the hyperplanes defining the convex hull
+            of the bounds of the reference points. A point is a valid reference point if it lies within the convex hull.
+        np.ndarray: A (num_dims-1) array of the constants of the hyperplanes defining the convex hull. See above.
+        scipy.spatial.ConvexHull: The convex hull of the projected vertices/valid reference points.
+    """
+    vertices = np.array(list(product([0, 1], repeat=num_dims)))
+
+    # Project vertices onto plane perpendicular to largest space diagonal, rotate to make one of the objectives zero.
+    # Then flatten to (num_dims-1) dimensions.
+    rotated_vertices = rotate_in(vertices)
+
+    bounding_box = np.array([np.min(rotated_vertices, axis=0), np.max(rotated_vertices, axis=0)])
+
+    hull = ConvexHull(rotated_vertices)
+
+    A, b = get_hull_equations(hull)
+
+    return bounding_box, A, b, hull
+
+
+def rotate_in(vertices):
+    """
+
+    Args:
+        vertices (_type_): _description_
+
+    Returns:
+        _type_: _description_
+    """
+    num_dims = len(vertices[0])
+    rotated_vertices = rotate([1] * num_dims, ([0] * (num_dims - 1) + [1]), vertices)
+    rotated_vertices = rotated_vertices[:, :-1]
+    return rotated_vertices
+
+
+def rotate_out(points):
+    points = np.atleast_2d(points)
+    num_points, num_dims = points.shape
+    points_rotated = np.hstack((points, np.ones((len(points), 1))))
+    points_rotated = rotate(([0] * (num_dims) + [1]), [1] * (num_dims + 1), points_rotated)
+    # Move (along nadir-ideal direction) the plane of these points such that it passes through nadir
+    points_rotated = points_rotated + 1 - 1 / np.sqrt(num_dims + 1)
+    return points_rotated
+
+
+def get_hull_equations(hull):
+    """Get the equations of the hyperplanes defining the convex hull.
+
+    Args:
+        hull (scipy.spatial.ConvexHull): A convex hull.
+
+    Returns:
+        np.ndarray: A (num_dims-1) x num_hyperplanes array of the coefficients of the hyperplanes defining the convex
+            hull.
+        np.ndarray: A (num_hyperplanes) array of the constants of the hyperplanes defining the convex hull.
+    """
+
+    return np.ascontiguousarray(hull.equations[:, :-1].T), np.ascontiguousarray(hull.equations[:, -1].T)
+
+
+def generate_points(
+    num_points: int, num_dims: int
+) -> tuple[
+    np.ndarray,
+    np.ndarray,
+]:
+    """Generate reference points for the IPA algorithm.
+
+    Creates a (large) number of reference points on a plane perpendicular to the largest space diagonal of the unit
+    hypercube in the num_dims-dimensional space. First, the vertices of the unit hypercube are generated. Then, the
+    vertices are projected onto the plane perpendicular to the largest space diagonal (vertex first parallel
+    projection) and rotated such that the plane is perpendular to one of the axes, making all objective values zero.
+    A convex hull is then constructed from the projected vertices, and a bounding box is constructed
+    around the convex hull. Finally, points are generated uniformly within the bounding box until num_points points
+    are generated _inside_ the convex hull. Note that the number of dimensions must be at least 2. Also, the number of
+    dimensions of the reference points is one less than the number of dimensions of the objective space. This is because
+    the reference points are generated on the projected plane.
+
+    Args:
+        num_points (int): The number of reference points to generate.
+        num_dims (int): The number of dimensions of the space in which the reference points are generated.
+
+    Returns:
+        np.ndarray: A (num_points) x (num_dims-1) array of reference points.
+    """
+
+    bounding_box, A, b, _ = get_reference_hull(num_dims)
+    points = numba_random_gen(num_points, bounding_box, A, b)
+    # Project vertices onto plane perpendicular to largest space diagonal
+    points_rotated = rotate_out(points)
+    return points, points_rotated
+
+
+@njit()
+def numba_random_gen(num_points: int, bounding_box: np.ndarray, A: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Generates num_points random points within the convex hull defined by A and b."""
+    num_dims_ = bounding_box.shape[1]
+    points = np.zeros((num_points, num_dims_))
+
+    eps = np.finfo(np.float32).eps
+
+    counter = 0
+
+    while counter < num_points:
+        point = np.zeros(num_dims_)
+        for i in range(num_dims_):
+            # Generate a random point within the bounding box
+            point[i] = np.random.uniform(bounding_box[0, i], bounding_box[1, i])
+        if np.all(point @ A + b < eps):
+            # If the point is inside the convex hull, add it to the list of points
+            points[counter] = point
+            counter += 1
+    return points