Return to Question

from numpy import arange


class RiemannSum(object):

    def __init__(self, index, upper, rectangles, func, endpoints='mid'):
        """
        Constructor for base class for Riemann Sums.
        Will be subclassed for left, right, or mid-points for rectangles.

        :param index: Where to begin 'n' value. [n = index]
        :param upper: Upper bound of sum.  Max 'n' value.  [Number above sigma notation]
        :param rectangles: The number of rectangles to be used in the calculation.
        :param func: pass series function here; suggest assigning lambda function to variable and passing here
        :param endpoints: default to 'mid'. Valid values are 'mid', 'left', 'right' as strings
        """
        self.total = 0
        self.index = index
        self.upper = upper
        self.delta = (upper - index) / rectangles
        self.function = func

        if endpoints == 'left':  # left endpoints
            self.points = arange(self.index, self.upper, self.delta)
        elif endpoints == 'right':  # right endpoints
            self.points = arange(self.index + self.delta, self.upper + self.delta, self.delta)
        else:  # mid endpoints, usually most accurate
            diff = self.delta / 2
            self.points = [i for i in arange((self.index + diff),
                                         (self.upper + diff), self.delta)]

    def sum(self):
        outputs = [i for i in map(self.function, self.points)]
        self.total = sum(outputs)
        return self.delta * self.total

from numpy import arange


class RiemannSum(object):

    def __init__(self, index, upper, rectangles, func, endpoints='mid'):
        """
        Constructor for base class for Riemann Sums.
        Will be subclassed for left, right, or mid-points for rectangles.

        :param index: Where to begin 'n' value. [n = index]
        :param upper: Upper bound of sum.  Max 'n' value.  [Number above sigma notation]
        :param rectangles: The number of rectangles to be used in the calculation.
        :param func: pass series function here; suggest assigning lambda function to variable and passing here
        :param endpoints: default to 'mid'. Valid values are 'mid', 'left', 'right' as strings
        """
        self.total = 0
        self.index = index
        self.upper = upper
        self.delta = (upper - index) / rectangles
        self.function = func

        if endpoints.lower() == 'left':  # left endpoints
            self.points = arange(self.index, self.upper, self.delta)
        elif endpoints.lower() == 'right':  # right endpoints
            self.points = arange(self.index + self.delta, self.upper + self.delta, self.delta)
        else:  # mid endpoints, usually most accurate
            diff = self.delta / 2
            self.points = [i for i in arange((self.index + diff),
                                         (self.upper + diff), self.delta)]

    def sum(self):
        outputs = [i for i in map(self.function, self.points)]
        self.total = sum(outputs)
        return self.delta * self.total

from numpy import arange


class RiemannSum(object):

def __init__(self, index, upper, rectangles, func, endpoints='mid'):
    """
    Constructor for base class for Riemann Sums.
    Will be subclassed for left, right, or mid-points for rectangles.

    :param index: Where to begin 'n' value. [n = index]
    :param upper: Upper bound of sum.  Max 'n' value.  [Number above sigma notation]
    :param rectangles: The number of rectangles to be used in the calculation.
    :param func: pass series function here; suggest assigning lambda function to variable and passing here
    :param endpoints: default to 'mid'. Valid values are 'mid', 'left', 'right' as strings
    """
    self.total = 0
    self.index = index
    self.upper = upper
    self.delta = (upper - index) / rectangles
    self.function = func
    self.endpoints = endpoints
    if self.endpoints == 'left':  # left endpoints
        self.points = arange(self.index, self.upper, self.delta)
    if self.endpoints == 'right':  # right endpoints
        self.points = arange(self.index + self.delta, self.upper + self.delta, self.delta)
    else:  # mid endpoints, usually most accurate
        diff = self.delta / 2
        self.points = [i for i in arange((self.index + diff),
                                         (self.upper + diff), self.delta)]

def sum(self):
    outputs = [i for i in map(self.function, self.points)]
    self.total = sum(outputs)
    return self.delta * self.total

from numpy import arange


class RiemannSum(object):

    def __init__(self, index, upper, rectangles, func, endpoints='mid'):
        """
        Constructor for base class for Riemann Sums.
        Will be subclassed for left, right, or mid-points for rectangles.

        :param index: Where to begin 'n' value. [n = index]
        :param upper: Upper bound of sum.  Max 'n' value.  [Number above sigma notation]
        :param rectangles: The number of rectangles to be used in the calculation.
        :param func: pass series function here; suggest assigning lambda function to variable and passing here
        :param endpoints: default to 'mid'. Valid values are 'mid', 'left', 'right' as strings
        """
        self.total = 0
        self.index = index
        self.upper = upper
        self.delta = (upper - index) / rectangles
        self.function = func 

        if endpoints == 'left':  # left endpoints
            self.points = arange(self.index, self.upper, self.delta)
        elif endpoints == 'right':  # right endpoints
            self.points = arange(self.index + self.delta, self.upper + self.delta, self.delta)
        else:  # mid endpoints, usually most accurate
            diff = self.delta / 2
            self.points = [i for i in arange((self.index + diff),
                                         (self.upper + diff), self.delta)]

    def sum(self):
        outputs = [i for i in map(self.function, self.points)]
        self.total = sum(outputs)
        return self.delta * self.total