game_qu.math.bounded_function API documentation

# Module `game_qu.math.bounded_function`

Expand source code

    from game_qu.base.utility_functions import is_within_bounds
    from game_qu.math.function import Function
    from game_qu.math.piecewise_function import PiecewiseFunction

    class BoundedFunction(Function):
        x_coordinates_can_be_less_than_min = False
        is_repeating = False
        min_x_coordinate = 0
        max_x_coordinate = 0
        unmodified_function = None
        current_function = None

        def __init__(self, function, min_x_coordinate, max_x_coordinate):
            """Initializes the object with the specified bounds"""

            self.set_bounds(min_x_coordinate, max_x_coordinate)
            self.set_function(function)

        def get_min_x_coordinate(self) -> float:
            """
                 Returns:
                    float: the minimum x coordinate"""

            return self.min_x_coordinate

        def get_max_x_coordinate(self) -> float:
            """
                 Returns:
                    float: the maximum x coordinate"""

            return self.max_x_coordinate

        def set_min_x_coordinate(self, min_x_coordinate):
            """ Sets the minimum x-coordinate to 'min_x_coordinate'

                Returns:
                    BoundedFunction: 'self'"""

            self.min_x_coordinate = min_x_coordinate
            return self

        def get_bounded_function_with_min_x_coordinate(self, min_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified min_x_coordinate (does not modify the current bounded function)"""

            return self.get_copy().set_min_x_coordinate(min_x_coordinate)

        def set_max_x_coordinate(self, max_x_coordinate):
            """Sets the maximum x-coordinate to 'max_x_coordinate'

                Returns:
                    BoundedFunction: 'self'"""

            self.max_x_coordinate = max_x_coordinate
            return self

        def get_bounded_function_with_max_x_coordinate(self, max_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified max_x_coordinate (does not modify the current bounded function)"""

            return self.get_copy().set_max_x_coordinate(max_x_coordinate)

        def set_bounds(self, min_x_coordinate, max_x_coordinate):
            """ Sets both minimum and maximum x coordinates (bounds)

                Returns:
                    BoundedFunction: 'self'"""

            self.set_min_x_coordinate(min_x_coordinate)
            self.set_max_x_coordinate(max_x_coordinate)
            self.update_current_function()
            return self

        def get_bounded_function_with_bounds(self, min_x_coordinate, max_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified bounds (does not modify the current bounded function)"""

            return self.get_copy().set_bounds(min_x_coordinate, max_x_coordinate)

        def get_coordinates(self) -> tuple:
            """
                 Returns:
                    tuple: (min_x_coordinate, max_x_coordinate)"""

            return self.min_x_coordinate, self.max_x_coordinate

        def get_copy(self):
            """
                 Returns:
                BoundedFunction; a copy of the bounded function"""

            return BoundedFunction(self.min_x_coordinate, self.max_x_coordinate)

        def get_function(self):
            """
                 Returns:
                    function: the stored function"""

            return self.current_function

        def set_function(self, function):
            """ Sets the underlying function to 'function'

                Returns:
                    BoundedFunction: 'self"""

            self.unmodified_function = function
            self.update_current_function()
            return self

        def get_bounded_function_with_function(self, function):
            """
                 Returns:
                    BoundedFunction: a bounded function with the underlying function being 'function' (does not modify the current bounded function)"""

            return self.get_copy().set_function(function)

        def get_is_repeating(self):
            """
                 Returns:
                    boolean: whether the function repeats"""

            return self.is_repeating

        def set_is_repeating(self, is_repeating):
            """ Sets the is_repeating attribute to 'is_repeating'

                Returns:
                    BoundedFunction: 'self'"""

            self.is_repeating = is_repeating
            return self

        def get_bounded_function_with_is_repeating(self, is_repeating):
            """
                 Returns:
                    BoundedFunction: a bounded function with the is repeating attribute set to 'is_repeating' (does not modify the current bounded function)"""

            return self.get_copy().set_is_repeating(is_repeating)

        def get_x_coordinates_can_be_less_than_min(self):
            """
                 Returns:
                    bool: whether the x coordinates this function accepts can be less than the min x coordinate"""

            return self.x_coordinates_can_be_less_than_min

        def set_x_coordinates_can_be_less_than_min(self, x_coordinates_can_be_less_than_min):
            """
                 Returns:
                    bool: sets whether the x coordinates this function accepts can be less than the min x coordinate
                    returns: BoundedFunction; 'self'"""

            value_has_changed = self.x_coordinates_can_be_less_than_min != x_coordinates_can_be_less_than_min
            if value_has_changed and x_coordinates_can_be_less_than_min:
                self.update_current_function()

            if x_coordinates_can_be_less_than_min:
                self.current_function = self.unmodified_function

            self.x_coordinates_can_be_less_than_min = x_coordinates_can_be_less_than_min
            return self

        def get_full_function(self):
            """
                 Returns:
                    PiecewiseFunction: the fully 'unbounded' function - x coordinates can now be less than the min x
                    x coordinate"""

            start = self.get_min_x_coordinate() - self.bounds_size()
            end = self.get_max_x_coordinate() - self.bounds_size()
            bounds_size = self.bounds_size()  # This is the bounds size do not change if the original bounds size change!

            before_function = self.get_bounded_function_with_bounds(start, end)
            before_function.get_y_coordinate = lambda x: before_function.get_y_coordinate(x - bounds_size)

            return PiecewiseFunction([self.get_copy(), before_function])

        def update_current_function(self):
            """Updates the current function after the bounded function is updated"""

            if self.x_coordinates_can_be_less_than_min:
                self.current_function = self.get_full_function()

            else:
                self.current_function = self.unmodified_function

        def get_bounded_function_with_x_coordinates_less_than_min(self, x_coordinates_can_be_less_than_min):
            """
                 Returns:
                    BoundedFunction: a bounded function with the is repeating attribute set to 'x_coordinates_can_be_less_than_min' (does not modify the current bounded function)"""

            return self.get_copy().set_x_coordinates_can_be_less_than_min(x_coordinates_can_be_less_than_min)

        def get_y_coordinate(self, x_coordinate):
            """
                 Returns:
                    float: the y_coordinate associated with that value"""

            if not self.is_repeating and not is_within_bounds(x_coordinate, self.min_x_coordinate, self.max_x_coordinate):
                raise ValueError("The x coordinate must be within the bounds specified because this function has strict bounds")

            return self.current_function.get_y_coordinate(x_coordinate)

        def get_x_coordinate(self, y_coordinate):
            """
                 Returns:
                    float: the x coordinate associated with that y coordinate (raises a ValueError if the function does
                    not implement the get_inverse_function() method"""

            return self.current_function.get_x_coordinate(y_coordinate)

        def get_bounds(self):
            """
                 Returns:
                    list[float]: {min_x_coordinate, max_x_coordinate}; the bounds of the function"""

            return [self.min_x_coordinate, self.max_x_coordinate]

        def bounds_size(self):
            """
                 Returns:
                    float: the size of the bounds (max - min)"""

            return self.max_x_coordinate - self.min_x_coordinate

        def get_min(self):
            """
                 Returns:
                    float: the value of the function at the min x coordinate"""

            return self.current_function.get_y_coordinate(self.min_x_coordinate)

        def get_max(self):
            """
                 Returns:
                    float: the value of the function at the max x coordinate"""

            return self.current_function.get_y_coordinate(self.max_x_coordinate)

        def get_indefinite_integral(self):
            """ Finds and returns the indefinite integral. Raises an AttributeError if the underlying function does not have the
                method: 'get_indefinite_integral'

                Returns:
                    IndefiniteIntegral: the indefinite integral of the polynomial"""

            return self.current_function.get_indefinite_integral()

        def evaluate_area(self, start, end):
            """
                 Returns:
                    float: the value gotten from using the bounds for the indefinite integral"""

            return self.get_indefinite_integral().evaluate(start, end)

        def get_derivative(self):
            """ Finds and returns the derivative. Raises an AttributeError if the underlying function do not have the
                method: 'get_derivative'

                Returns:
                    Derivative: the derivative of the polynomial"""

            return self.current_function.get_derivative()

        def evaluate_derivative_at_point(self, x_coordinate):
            """
                 Returns:
                    float: the value of the derivative evaluated at the 'x_coordinate'"""

            return self.get_derivative().evaluate(x_coordinate)

## Classes

`class BoundedFunction (function, min_x_coordinate, max_x_coordinate)`

  Anything that maps an x value to a y value. This is an abstract class with two methods. Only 'get_y_coordinate' must be implemented

  Initializes the object with the specified bounds

  Expand source code

      class BoundedFunction(Function):
          x_coordinates_can_be_less_than_min = False
          is_repeating = False
          min_x_coordinate = 0
          max_x_coordinate = 0
          unmodified_function = None
          current_function = None

          def __init__(self, function, min_x_coordinate, max_x_coordinate):
              """Initializes the object with the specified bounds"""

              self.set_bounds(min_x_coordinate, max_x_coordinate)
              self.set_function(function)

          def get_min_x_coordinate(self) -> float:
              """
                   Returns:
                      float: the minimum x coordinate"""

              return self.min_x_coordinate

          def get_max_x_coordinate(self) -> float:
              """
                   Returns:
                      float: the maximum x coordinate"""

              return self.max_x_coordinate

          def set_min_x_coordinate(self, min_x_coordinate):
              """ Sets the minimum x-coordinate to 'min_x_coordinate'

                  Returns:
                      BoundedFunction: 'self'"""

              self.min_x_coordinate = min_x_coordinate
              return self

          def get_bounded_function_with_min_x_coordinate(self, min_x_coordinate):
              """
                   Returns:
                      BoundedFunction: a bounded function with the specified min_x_coordinate (does not modify the current bounded function)"""

              return self.get_copy().set_min_x_coordinate(min_x_coordinate)

          def set_max_x_coordinate(self, max_x_coordinate):
              """Sets the maximum x-coordinate to 'max_x_coordinate'

                  Returns:
                      BoundedFunction: 'self'"""

              self.max_x_coordinate = max_x_coordinate
              return self

          def get_bounded_function_with_max_x_coordinate(self, max_x_coordinate):
              """
                   Returns:
                      BoundedFunction: a bounded function with the specified max_x_coordinate (does not modify the current bounded function)"""

              return self.get_copy().set_max_x_coordinate(max_x_coordinate)

          def set_bounds(self, min_x_coordinate, max_x_coordinate):
              """ Sets both minimum and maximum x coordinates (bounds)

                  Returns:
                      BoundedFunction: 'self'"""

              self.set_min_x_coordinate(min_x_coordinate)
              self.set_max_x_coordinate(max_x_coordinate)
              self.update_current_function()
              return self

          def get_bounded_function_with_bounds(self, min_x_coordinate, max_x_coordinate):
              """
                   Returns:
                      BoundedFunction: a bounded function with the specified bounds (does not modify the current bounded function)"""

              return self.get_copy().set_bounds(min_x_coordinate, max_x_coordinate)

          def get_coordinates(self) -> tuple:
              """
                   Returns:
                      tuple: (min_x_coordinate, max_x_coordinate)"""

              return self.min_x_coordinate, self.max_x_coordinate

          def get_copy(self):
              """
                   Returns:
                  BoundedFunction; a copy of the bounded function"""

              return BoundedFunction(self.min_x_coordinate, self.max_x_coordinate)

          def get_function(self):
              """
                   Returns:
                      function: the stored function"""

              return self.current_function

          def set_function(self, function):
              """ Sets the underlying function to 'function'

                  Returns:
                      BoundedFunction: 'self"""

              self.unmodified_function = function
              self.update_current_function()
              return self

          def get_bounded_function_with_function(self, function):
              """
                   Returns:
                      BoundedFunction: a bounded function with the underlying function being 'function' (does not modify the current bounded function)"""

              return self.get_copy().set_function(function)

          def get_is_repeating(self):
              """
                   Returns:
                      boolean: whether the function repeats"""

              return self.is_repeating

          def set_is_repeating(self, is_repeating):
              """ Sets the is_repeating attribute to 'is_repeating'

                  Returns:
                      BoundedFunction: 'self'"""

              self.is_repeating = is_repeating
              return self

          def get_bounded_function_with_is_repeating(self, is_repeating):
              """
                   Returns:
                      BoundedFunction: a bounded function with the is repeating attribute set to 'is_repeating' (does not modify the current bounded function)"""

              return self.get_copy().set_is_repeating(is_repeating)

          def get_x_coordinates_can_be_less_than_min(self):
              """
                   Returns:
                      bool: whether the x coordinates this function accepts can be less than the min x coordinate"""

              return self.x_coordinates_can_be_less_than_min

          def set_x_coordinates_can_be_less_than_min(self, x_coordinates_can_be_less_than_min):
              """
                   Returns:
                      bool: sets whether the x coordinates this function accepts can be less than the min x coordinate
                      returns: BoundedFunction; 'self'"""

              value_has_changed = self.x_coordinates_can_be_less_than_min != x_coordinates_can_be_less_than_min
              if value_has_changed and x_coordinates_can_be_less_than_min:
                  self.update_current_function()

              if x_coordinates_can_be_less_than_min:
                  self.current_function = self.unmodified_function

              self.x_coordinates_can_be_less_than_min = x_coordinates_can_be_less_than_min
              return self

          def get_full_function(self):
              """
                   Returns:
                      PiecewiseFunction: the fully 'unbounded' function - x coordinates can now be less than the min x
                      x coordinate"""

              start = self.get_min_x_coordinate() - self.bounds_size()
              end = self.get_max_x_coordinate() - self.bounds_size()
              bounds_size = self.bounds_size()  # This is the bounds size do not change if the original bounds size change!

              before_function = self.get_bounded_function_with_bounds(start, end)
              before_function.get_y_coordinate = lambda x: before_function.get_y_coordinate(x - bounds_size)

              return PiecewiseFunction([self.get_copy(), before_function])

          def update_current_function(self):
              """Updates the current function after the bounded function is updated"""

              if self.x_coordinates_can_be_less_than_min:
                  self.current_function = self.get_full_function()

              else:
                  self.current_function = self.unmodified_function

          def get_bounded_function_with_x_coordinates_less_than_min(self, x_coordinates_can_be_less_than_min):
              """
                   Returns:
                      BoundedFunction: a bounded function with the is repeating attribute set to 'x_coordinates_can_be_less_than_min' (does not modify the current bounded function)"""

              return self.get_copy().set_x_coordinates_can_be_less_than_min(x_coordinates_can_be_less_than_min)

          def get_y_coordinate(self, x_coordinate):
              """
                   Returns:
                      float: the y_coordinate associated with that value"""

              if not self.is_repeating and not is_within_bounds(x_coordinate, self.min_x_coordinate, self.max_x_coordinate):
                  raise ValueError("The x coordinate must be within the bounds specified because this function has strict bounds")

              return self.current_function.get_y_coordinate(x_coordinate)

          def get_x_coordinate(self, y_coordinate):
              """
                   Returns:
                      float: the x coordinate associated with that y coordinate (raises a ValueError if the function does
                      not implement the get_inverse_function() method"""

              return self.current_function.get_x_coordinate(y_coordinate)

          def get_bounds(self):
              """
                   Returns:
                      list[float]: {min_x_coordinate, max_x_coordinate}; the bounds of the function"""

              return [self.min_x_coordinate, self.max_x_coordinate]

          def bounds_size(self):
              """
                   Returns:
                      float: the size of the bounds (max - min)"""

              return self.max_x_coordinate - self.min_x_coordinate

          def get_min(self):
              """
                   Returns:
                      float: the value of the function at the min x coordinate"""

              return self.current_function.get_y_coordinate(self.min_x_coordinate)

          def get_max(self):
              """
                   Returns:
                      float: the value of the function at the max x coordinate"""

              return self.current_function.get_y_coordinate(self.max_x_coordinate)

          def get_indefinite_integral(self):
              """ Finds and returns the indefinite integral. Raises an AttributeError if the underlying function does not have the
                  method: 'get_indefinite_integral'

                  Returns:
                      IndefiniteIntegral: the indefinite integral of the polynomial"""

              return self.current_function.get_indefinite_integral()

          def evaluate_area(self, start, end):
              """
                   Returns:
                      float: the value gotten from using the bounds for the indefinite integral"""

              return self.get_indefinite_integral().evaluate(start, end)

          def get_derivative(self):
              """ Finds and returns the derivative. Raises an AttributeError if the underlying function do not have the
                  method: 'get_derivative'

                  Returns:
                      Derivative: the derivative of the polynomial"""

              return self.current_function.get_derivative()

          def evaluate_derivative_at_point(self, x_coordinate):
              """
                   Returns:
                      float: the value of the derivative evaluated at the 'x_coordinate'"""

              return self.get_derivative().evaluate(x_coordinate)

  ### Ancestors

  - Function
  - abc.ABC

  ### Class variables

  `var current_function`
  `var is_repeating`
  `var max_x_coordinate`
  `var min_x_coordinate`
  `var unmodified_function`
  `var x_coordinates_can_be_less_than_min`

  ### Methods

  `def bounds_size(self)`

    ## Returns

    `float`
      the size of the bounds (max - min)
    Expand source code

        def bounds_size(self):
            """
                 Returns:
                    float: the size of the bounds (max - min)"""

            return self.max_x_coordinate - self.min_x_coordinate

  `def evaluate_area(self, start, end)`

    ## Returns

    `float`
      the value gotten from using the bounds for the indefinite integral
    Expand source code

        def evaluate_area(self, start, end):
            """
                 Returns:
                    float: the value gotten from using the bounds for the indefinite integral"""

            return self.get_indefinite_integral().evaluate(start, end)

  `def evaluate_derivative_at_point(self, x_coordinate)`

    ## Returns

    `float`
      the value of the derivative evaluated at the 'x_coordinate'
    Expand source code

        def evaluate_derivative_at_point(self, x_coordinate):
            """
                 Returns:
                    float: the value of the derivative evaluated at the 'x_coordinate'"""

            return self.get_derivative().evaluate(x_coordinate)

  `def get_bounded_function_with_bounds(self, min_x_coordinate, max_x_coordinate)`

    ## Returns

    `BoundedFunction`
      a bounded function with the specified bounds (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_bounds(self, min_x_coordinate, max_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified bounds (does not modify the current bounded function)"""

            return self.get_copy().set_bounds(min_x_coordinate, max_x_coordinate)

  `def get_bounded_function_with_function(self, function)`

    ## Returns

    `BoundedFunction`
      a bounded function with the underlying function being 'function' (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_function(self, function):
            """
                 Returns:
                    BoundedFunction: a bounded function with the underlying function being 'function' (does not modify the current bounded function)"""

            return self.get_copy().set_function(function)

  `def get_bounded_function_with_is_repeating(self, is_repeating)`

    ## Returns

    `BoundedFunction`
      a bounded function with the is repeating attribute set to 'is_repeating' (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_is_repeating(self, is_repeating):
            """
                 Returns:
                    BoundedFunction: a bounded function with the is repeating attribute set to 'is_repeating' (does not modify the current bounded function)"""

            return self.get_copy().set_is_repeating(is_repeating)

  `def get_bounded_function_with_max_x_coordinate(self, max_x_coordinate)`

    ## Returns

    `BoundedFunction`
      a bounded function with the specified max_x_coordinate (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_max_x_coordinate(self, max_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified max_x_coordinate (does not modify the current bounded function)"""

            return self.get_copy().set_max_x_coordinate(max_x_coordinate)

  `def get_bounded_function_with_min_x_coordinate(self, min_x_coordinate)`

    ## Returns

    `BoundedFunction`
      a bounded function with the specified min_x_coordinate (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_min_x_coordinate(self, min_x_coordinate):
            """
                 Returns:
                    BoundedFunction: a bounded function with the specified min_x_coordinate (does not modify the current bounded function)"""

            return self.get_copy().set_min_x_coordinate(min_x_coordinate)

  `def get_bounded_function_with_x_coordinates_less_than_min(self, x_coordinates_can_be_less_than_min)`

    ## Returns

    `BoundedFunction`
      a bounded function with the is repeating attribute set to 'x_coordinates_can_be_less_than_min' (does not modify the current bounded function)
    Expand source code

        def get_bounded_function_with_x_coordinates_less_than_min(self, x_coordinates_can_be_less_than_min):
            """
                 Returns:
                    BoundedFunction: a bounded function with the is repeating attribute set to 'x_coordinates_can_be_less_than_min' (does not modify the current bounded function)"""

            return self.get_copy().set_x_coordinates_can_be_less_than_min(x_coordinates_can_be_less_than_min)

  `def get_bounds(self)`

    ## Returns

    `list[float]`
      {min_x_coordinate, max_x_coordinate}; the bounds of the function
    Expand source code

        def get_bounds(self):
            """
                 Returns:
                    list[float]: {min_x_coordinate, max_x_coordinate}; the bounds of the function"""

            return [self.min_x_coordinate, self.max_x_coordinate]

  `def get_coordinates(self) ‑> tuple`

    ## Returns

    `tuple`
      (min_x_coordinate, max_x_coordinate)
    Expand source code

        def get_coordinates(self) -> tuple:
            """
                 Returns:
                    tuple: (min_x_coordinate, max_x_coordinate)"""

            return self.min_x_coordinate, self.max_x_coordinate

  `def get_copy(self)`

    Returns: BoundedFunction; a copy of the bounded function

    Expand source code

        def get_copy(self):
            """
                 Returns:
                BoundedFunction; a copy of the bounded function"""

            return BoundedFunction(self.min_x_coordinate, self.max_x_coordinate)

  `def get_derivative(self)`

    Finds and returns the derivative. Raises an AttributeError if the underlying function do not have the method: 'get_derivative'

    ## Returns

    `Derivative`
      the derivative of the polynomial
    Expand source code

        def get_derivative(self):
            """ Finds and returns the derivative. Raises an AttributeError if the underlying function do not have the
                method: 'get_derivative'

                Returns:
                    Derivative: the derivative of the polynomial"""

            return self.current_function.get_derivative()

  `def get_full_function(self)`

    ## Returns

    `PiecewiseFunction`
      the fully 'unbounded' function - x coordinates can now be less than the min x

    x coordinate

    Expand source code

        def get_full_function(self):
            """
                 Returns:
                    PiecewiseFunction: the fully 'unbounded' function - x coordinates can now be less than the min x
                    x coordinate"""

            start = self.get_min_x_coordinate() - self.bounds_size()
            end = self.get_max_x_coordinate() - self.bounds_size()
            bounds_size = self.bounds_size()  # This is the bounds size do not change if the original bounds size change!

            before_function = self.get_bounded_function_with_bounds(start, end)
            before_function.get_y_coordinate = lambda x: before_function.get_y_coordinate(x - bounds_size)

            return PiecewiseFunction([self.get_copy(), before_function])

  `def get_function(self)`

    ## Returns

    `function`
      the stored function
    Expand source code

        def get_function(self):
            """
                 Returns:
                    function: the stored function"""

            return self.current_function

  `def get_indefinite_integral(self)`

    Finds and returns the indefinite integral. Raises an AttributeError if the underlying function does not have the method: 'get_indefinite_integral'

    ## Returns

    `IndefiniteIntegral`
      the indefinite integral of the polynomial
    Expand source code

        def get_indefinite_integral(self):
            """ Finds and returns the indefinite integral. Raises an AttributeError if the underlying function does not have the
                method: 'get_indefinite_integral'

                Returns:
                    IndefiniteIntegral: the indefinite integral of the polynomial"""

            return self.current_function.get_indefinite_integral()

  `def get_is_repeating(self)`

    ## Returns

    `boolean`
      whether the function repeats
    Expand source code

        def get_is_repeating(self):
            """
                 Returns:
                    boolean: whether the function repeats"""

            return self.is_repeating

  `def get_max(self)`

    ## Returns

    `float`
      the value of the function at the max x coordinate
    Expand source code

        def get_max(self):
            """
                 Returns:
                    float: the value of the function at the max x coordinate"""

            return self.current_function.get_y_coordinate(self.max_x_coordinate)

  `def get_max_x_coordinate(self) ‑> float`

    ## Returns

    `float`
      the maximum x coordinate
    Expand source code

        def get_max_x_coordinate(self) -> float:
            """
                 Returns:
                    float: the maximum x coordinate"""

            return self.max_x_coordinate

  `def get_min(self)`

    ## Returns

    `float`
      the value of the function at the min x coordinate
    Expand source code

        def get_min(self):
            """
                 Returns:
                    float: the value of the function at the min x coordinate"""

            return self.current_function.get_y_coordinate(self.min_x_coordinate)

  `def get_min_x_coordinate(self) ‑> float`

    ## Returns

    `float`
      the minimum x coordinate
    Expand source code

        def get_min_x_coordinate(self) -> float:
            """
                 Returns:
                    float: the minimum x coordinate"""

            return self.min_x_coordinate

  `def get_x_coordinate(self, y_coordinate)`

    ## Returns

    `float`
      the x coordinate associated with that y coordinate (raises a ValueError if the function does

    not implement the get_inverse_function() method

    Expand source code

        def get_x_coordinate(self, y_coordinate):
            """
                 Returns:
                    float: the x coordinate associated with that y coordinate (raises a ValueError if the function does
                    not implement the get_inverse_function() method"""

            return self.current_function.get_x_coordinate(y_coordinate)

  `def get_x_coordinates_can_be_less_than_min(self)`

    ## Returns

    `bool`
      whether the x coordinates this function accepts can be less than the min x coordinate
    Expand source code

        def get_x_coordinates_can_be_less_than_min(self):
            """
                 Returns:
                    bool: whether the x coordinates this function accepts can be less than the min x coordinate"""

            return self.x_coordinates_can_be_less_than_min

  `def get_y_coordinate(self, x_coordinate)`

    ## Returns

    `float`
      the y_coordinate associated with that value
    Expand source code

        def get_y_coordinate(self, x_coordinate):
            """
                 Returns:
                    float: the y_coordinate associated with that value"""

            if not self.is_repeating and not is_within_bounds(x_coordinate, self.min_x_coordinate, self.max_x_coordinate):
                raise ValueError("The x coordinate must be within the bounds specified because this function has strict bounds")

            return self.current_function.get_y_coordinate(x_coordinate)

  `def set_bounds(self, min_x_coordinate, max_x_coordinate)`

    Sets both minimum and maximum x coordinates (bounds)

    ## Returns

    `BoundedFunction`
      'self'
    Expand source code

        def set_bounds(self, min_x_coordinate, max_x_coordinate):
            """ Sets both minimum and maximum x coordinates (bounds)

                Returns:
                    BoundedFunction: 'self'"""

            self.set_min_x_coordinate(min_x_coordinate)
            self.set_max_x_coordinate(max_x_coordinate)
            self.update_current_function()
            return self

  `def set_function(self, function)`

    Sets the underlying function to 'function'

    ## Returns

    `BoundedFunction`
      'self
    Expand source code

        def set_function(self, function):
            """ Sets the underlying function to 'function'

                Returns:
                    BoundedFunction: 'self"""

            self.unmodified_function = function
            self.update_current_function()
            return self

  `def set_is_repeating(self, is_repeating)`

    Sets the is_repeating attribute to 'is_repeating'

    ## Returns

    `BoundedFunction`
      'self'
    Expand source code

        def set_is_repeating(self, is_repeating):
            """ Sets the is_repeating attribute to 'is_repeating'

                Returns:
                    BoundedFunction: 'self'"""

            self.is_repeating = is_repeating
            return self

  `def set_max_x_coordinate(self, max_x_coordinate)`

    Sets the maximum x-coordinate to 'max_x_coordinate'

    ## Returns

    `BoundedFunction`
      'self'
    Expand source code

        def set_max_x_coordinate(self, max_x_coordinate):
            """Sets the maximum x-coordinate to 'max_x_coordinate'

                Returns:
                    BoundedFunction: 'self'"""

            self.max_x_coordinate = max_x_coordinate
            return self

  `def set_min_x_coordinate(self, min_x_coordinate)`

    Sets the minimum x-coordinate to 'min_x_coordinate'

    ## Returns

    `BoundedFunction`
      'self'
    Expand source code

        def set_min_x_coordinate(self, min_x_coordinate):
            """ Sets the minimum x-coordinate to 'min_x_coordinate'

                Returns:
                    BoundedFunction: 'self'"""

            self.min_x_coordinate = min_x_coordinate
            return self

  `def set_x_coordinates_can_be_less_than_min(self, x_coordinates_can_be_less_than_min)`

    ## Returns

    `bool`
      sets whether the x coordinates this function accepts can be less than the min x coordinate
    `returns`
      BoundedFunction; 'self'
    Expand source code

        def set_x_coordinates_can_be_less_than_min(self, x_coordinates_can_be_less_than_min):
            """
                 Returns:
                    bool: sets whether the x coordinates this function accepts can be less than the min x coordinate
                    returns: BoundedFunction; 'self'"""

            value_has_changed = self.x_coordinates_can_be_less_than_min != x_coordinates_can_be_less_than_min
            if value_has_changed and x_coordinates_can_be_less_than_min:
                self.update_current_function()

            if x_coordinates_can_be_less_than_min:
                self.current_function = self.unmodified_function

            self.x_coordinates_can_be_less_than_min = x_coordinates_can_be_less_than_min
            return self

  `def update_current_function(self)`

    Updates the current function after the bounded function is updated

    Expand source code

        def update_current_function(self):
            """Updates the current function after the bounded function is updated"""

            if self.x_coordinates_can_be_less_than_min:
                self.current_function = self.get_full_function()

            else:
                self.current_function = self.unmodified_function

  ### Inherited members

  - `Function`:
    - `get_inverted_function`
    - `get_new_function`