Welcome, guest | Sign In | My Account | Store | Cart
```#On the name of ALLAH and may the blessing and peace of Allah
#be upon the Messenger of Allah Mohamed Salla Allahu Aliahi Wassalam.
#Date : 09/09/09
#version :2.6.1

"""
Class Interval is the base class for every Rectangle Method's approximation
and inherits from tuple. However four main functions are defined within
Interval, delta_X, and the three different approximation's methods, the
leftEndPoint, the rightEndPoint, and the midPoint. Though, RectangleMethod
class inherits from Interval class, and call the three approximation's
methods to approximate a curve function y = f(x) and compare those methods'
results. And I chose the midPoint method to compute my ell_en and logarithm
functions.

"""

from collections import namedtuple

class Interval(namedtuple('Interval','n,a,b')):
"""
Interval class inherits from tuple
"""

#set __slots__ to an empty tuple keep memory requirements low
__slots__ = ()

@property
def delta_X(self):
"""
Compute Delta_X the length value of each part of the
subinterval[a,b] divided into n equal parts
"""

return (self.b - self.a )/float(self.n)

@property
def leftEndPoint(self):
"""
Compute the value of Xk of each point using the
left endpoint of each subinterval
"""

left_list = []

#attempt to create a list of Xk points using the left endpoint
try:
for k in range(1,self.n+1):
left_end_point = self.a + (k - 1)* self.delta_X
left_list.append(left_end_point)
return left_list

#Raise TypeError if input is not numerical
except TypeError:
print "\n<The entered value is not a number"

@property
def rightEndPoint(self):
"""
Compute the value of Xk of each point using the
right endpoint of each subinterval
"""

right_list = []

#attempt to create a list of Xk points using the right endpoint
try:
for k in range(1,(self.n +1)):
right_end_point = self.a + (k * self.delta_X)
right_list.append(right_end_point)
return right_list

#Raise TypeError if input is not numerical
except TypeError:
print "\n<The entered value is not a number"

@property
def midPoint(self):
"""
Compute the value of Xk of each point using the midPoint
of each subinterval
"""

mid_list = []

#attempt to create a list of Xk points using the midPoint
try:
for k in range(1,self.n + 1):
mid_point = self.a + ((k - 1/2.0)* self.delta_X)
mid_list.append(mid_point)
return mid_list

#Raise TypeError if input is not numerical
except TypeError:
print "\n<The entered value is not a number"

class RectangleMethod(Interval):
"""
Class RectangleMethod inherit from Interval class
"""
def Curve(self,**args):
"""
Compute and display the Left Endpoint, the Right Endpoint
and the midPoint approximaions of the area under a curve y = f(x)
over an interval [a,b]
"""

self.args = args

count = 0   #Set count to 0
total = 0   #Set total to 0

print '\n\t\tLeft Endpoint Approximation'
print '\t\t----------------------------'
print '\nk\t\tX_k\t\ty','\n'

# the curve y = f(x) is set to the 3rd degree of a form a + X**n
# could be switched into higher degree or trigonometric functions
for self.X_k in self.leftEndPoint:
self.left_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
+ self.args.get('b') *(float(self.X_k)**2)\
+ self.args.get('c')*(float(self.X_k))+ self.args.get('d'))
count +=1
total += float(self.left_curve)

print count,'\t\t',"%2.2f" % self.X_k,'\t\t',self.left_curve

print '\t\t\t\t--------'
print '\t\t\t\t',total
print '\t\t\t\t--------'
print 'left endpoint Approximation  =  %s' % (self.delta_X*total)
print

count_1 = 0 #Set count_1 to 0
total_1 = 0 #Set total_1 to 0

print '\n\t\tRight Endpoint Approximation'
print '\t\t----------------------------'
print '\nk\t\tX_k\t\ty','\n'

for self.X_k in self.rightEndPoint:
self.right_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
+ self.args.get('b') *(float(self.X_k)**2)\
+ self.args.get('c')*(float(self.X_k))+ self.args.get('d'))
count_1 +=1
total_1 += float(self.right_curve)

print count_1,'\t\t',"%2.2f" % self.X_k,'\t\t',self.right_curve

print '\t\t\t\t--------'
print '\t\t\t\t',total_1
print '\t\t\t\t--------'
print 'right endpoint Approximation =  %s' % (self.delta_X*total_1)
print

count_2 = 0 #Set count_2 to 0
total_2 = 0 #Set total_2 to 0

print '\n\t\tMidpoint Approximation'
print '\t\t----------------------'
print '\nk\t\tX_k\t\ty','\n'

for self.X_k in self.midPoint:
self.mid_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
+ self.args.get('b') *(float(self.X_k)**2)\
+ self.args.get('c')*(float(self.X_k))+ self.args.get('d'))
count_2 +=1
total_2 += float(self.mid_curve)

print count_2,'\t\t',"%2.2f" % self.X_k,'\t\t',self.mid_curve

print '\t\t\t\t--------'
print '\t\t\t\t',total_2
print '\t\t\t\t--------'
print '      midPoint Approximation =  %s' % (self.delta_X*total_2)

def ell_en(self,number):
"""
Computing ellen(ln) Approximation  for a given value.
"""

self.number = number

#attempt to Approximate In for a given value
try:
#Set RectangleMethod n and a fields to constant values
#and b field to a variable value, the greater the value of n
# the more accurate the result
rectangleMethod = RectangleMethod(n = 100000,a = 1, b=self.number)

sum_next = 0    #Set sum_next to 0

#inheriting and using midPoint function from Interval class
#to compute ln approximation.
for self.X_k in rectangleMethod.midPoint:

self.ell_en_X = 1/self.X_k
sum_next += self.ell_en_X
In = (sum_next * rectangleMethod.delta_X )
yield In

#Raise TypeError if input is not numerical
except TypeError:
print  "\n<The entered value is not a number"

def logarithm(self,base,value):
"""
Computing logarithm approximation for a given value
and a base of choice
"""

self.base = base
self.value = value

#attempt to Approximate logarithm for a given base and value
try:

for i in self.ell_en(self.value):
pass
for j in self.ell_en(self.base):
pass
result = round(i/j,8)

return "log_b%s(%s) = : %s " % (self.base,self.value,result)

#Raise TypeError if input is not numerical
except TypeError:
print  "\n<The entered value is not a number"

def exponential(self,value):
"""
Compute exponential e and exp(value) for a given value
"""

self.value = value

#attempt to yield an approximation of exp(n) for a given value
try:
for k in (1,100000000):
exp = ((1+1.0/k)**k)**value
yield exp

if self.value == 1:
print "e = %s " % repr(exp)
else:
print "exp(%s) = %s " % (value,repr(exp))

#Raise TypeError if input is not numerical
except TypeError:
print "Please enter a number "

if __name__ == '__main__':

# Create object of class RectangleMethod
rectangleMethod = RectangleMethod('n','a','b')

# create a curve y = 27 - X**2 over interval [0,3] with n =10
# for a better accuracy increase the value of n, n = 20, n = 30 ...
curve = RectangleMethod(10,0,3)
curve.Curve(a=0,b=-1,c=0,d=27)

# Create an object of ell_en to compute ln(x)
rectangleMethod = rectangleMethod._replace(b = 5)
ellen = rectangleMethod.ell_en(rectangleMethod.b)
for item in ellen:
pass
print '\n\t\tNatural Logarithm Approximation'
print '\t\t-------------------------------\n'
print "In(%s) = : %s " % (getattr(rectangleMethod,'b'),item)

# Create an object of logarithm ( base and value)
log_base_x = rectangleMethod.logarithm(2,16)
print '\n\t\tCommon Logarithm Approximation'
print '\t\t-------------------------------\n'
print log_base_x

# Create an object of exponential ( value )
print '\n\t\tExponential Approximation'
print '\t\t-------------------------\n'
for i in rectangleMethod.exponential(1):
pass

#C:\Windows\system32>python "C:\programs\Rectangle_Method.py"

#                Left Endpoint Approximation
#                ----------------------------

#k               X_k             y

#1               0.00            27.000000
#2               0.30            26.910000
#3               0.60            26.640000
#4               0.90            26.190000
#5               1.20            25.560000
#6               1.50            24.750000
#7               1.80            23.760000
#8               2.10            22.590000
#9               2.40            21.240000
#10              2.70            19.710000
#                                --------
#                                244.35
#                                --------
#left endpoint Approximation  =  73.305
#
#
#                Right Endpoint Approximation
#                ----------------------------
#
#k               X_k             y
#
#1               0.30            26.910000
#2               0.60            26.640000
#3               0.90            26.190000
#4               1.20            25.560000
#5               1.50            24.750000
#6               1.80            23.760000
#7               2.10            22.590000
#8               2.40            21.240000
#9               2.70            19.710000
#10              3.00            18.000000
#                                --------
#                                235.35
#                                --------
#right endpoint Approximation =  70.605
#
#
#                Midpoint Approximation
#                ----------------------
#
#k               X_k             y
#
#1               0.15            26.977500
#2               0.45            26.797500
#3               0.75            26.437500
#4               1.05            25.897500
#5               1.35            25.177500
#6               1.65            24.277500
#7               1.95            23.197500
#8               2.25            21.937500
#9               2.55            20.497500
#10              2.85            18.877500
#                                --------
#                                240.075
#                                --------
#      midPoint Approximation =  72.0225
#
#                Natural Logarithm Approximation
#                -------------------------------
#
#In(5) = : 1.60943791237
#
#                Common Logarithm Approximation
#                -------------------------------
#
#log_b2(16) = : 4.0
#
#                Exponential Approximation
#                -------------------------
#
#e = 2.7182817983473577
#
#
#

##########################################################################################
# Version : Python 3.2
#from collections import namedtuple

#class Interval(namedtuple('Interval','n,a,b')):
#    """
#    Interval class inherits from tuple
#    """
#
#    #set __slots__ to an empty tuple keep memory requirements low
#    __slots__ = ()
#
#    @property
#    def delta_X(self):
#        """
#        Compute Delta_X the length value of each part of the
#        subinterval[a,b] divided into n equal parts
#        """
#
#        return (self.b - self.a )/float(self.n)
#
#    @property
#    def leftEndPoint(self):
#        """
#        Compute the value of Xk of each point using the
#        left endpoint of each subinterval
#        """
#
#        left_list = []
#
#        #attempt to create a list of Xk points using the left endpoint
#        try:
#            for k in range(1,self.n+1):
#                left_end_point = self.a + (k - 1)* self.delta_X
#                left_list.append(left_end_point)
#            return left_list
#
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("\n<The entered value is not a number")
#
#    @property
#    def rightEndPoint(self):
#        """
#        Compute the value of Xk of each point using the
#        right endpoint of each subinterval
#        """
#
#        right_list = []
#
#        #attempt to create a list of Xk points using the right endpoint
#        try:
#            for k in range(1,(self.n +1)):
#                right_end_point = self.a + (k * self.delta_X)
#                right_list.append(right_end_point)
#            return right_list
#
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("\n<The entered value is not a number")
#
#    @property
#    def midPoint(self):
#        """
#        Compute the value of Xk of each point using the midPoint
#        of each subinterval
#        """
#
#        mid_list = []
#
#        #attempt to create a list of Xk points using the midPoint
#        try:
#            for k in range(1,self.n + 1):
#                mid_point = self.a + ((k - 1/2.0)* self.delta_X)
#                mid_list.append(mid_point)
#            return mid_list
#
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("\n<The entered value is not a number")
#
#class RectangleMethod(Interval):
#    """
#    Class RectangleMethod inherit from Interval class
#    """
#    def Curve(self,**args):
#        """
#        Compute and display the Left Endpoint, the Right Endpoint
#        and the midPoint approximaions of the area under a curve y = f(x)
#        over an interval [a,b]
#        """
#
#        self.args = args
#
#        count = 0   #Set count to 0
#        total = 0   #Set total to 0
#
#        print('\n\t\tLeft Endpoint Approximation')
#        print('\t\t----------------------------')
#        print('\nk\t\tX_k\t\ty','\n')
#
#        # the curve y = f(x) is set to the 3rd degree of a form a + X**n
#        # could be switched into higher degree or trigonometric functions
#        for self.X_k in self.leftEndPoint:
#            self.left_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
#                                + self.args.get('b') *(float(self.X_k)**2)\
#                                + self.args.get('c')*(float(self.X_k))+ self.args.get #('d'))
#            count +=1
#            total += float(self.left_curve)
#
#            print(count,'\t\t',"%2.2f" % self.X_k,'\t\t',self.left_curve)
#
#        print('\t\t\t\t--------')
#        print('\t\t\t\t',total)
#        print('\t\t\t\t--------')
#        print('left endpoint Approximation  =  %s' % (self.delta_X*total))
#        print()
#
#        count_1 = 0 #Set count_1 to 0
#        total_1 = 0 #Set total_1 to 0
#
#        print('\n\t\tRight Endpoint Approximation')
#        print('\t\t----------------------------')
#        print('\nk\t\tX_k\t\ty','\n')
#
#        for self.X_k in self.rightEndPoint:
#            self.right_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
#                                + self.args.get('b') *(float(self.X_k)**2)\
#                             + self.args.get('c')*(float(self.X_k))+ self.args.get('d'))
#            count_1 +=1
#            total_1 += float(self.right_curve)
#
#            print(count_1,'\t\t',"%2.2f" % self.X_k,'\t\t',self.right_curve)
#        print('\t\t\t\t--------')
#        print('\t\t\t\t',total_1)
#        print('\t\t\t\t--------')
#        print('right endpoint Approximation =  %s' % (self.delta_X*total_1))
#        print()
#
#        count_2 = 0 #Set count_2 to 0
#        total_2 = 0 #Set total_2 to 0
#
#        print('\n\t\tMidpoint Approximation')
#        print('\t\t----------------------')
#        print('\nk\t\tX_k\t\ty','\n')
#
#        for self.X_k in self.midPoint:
#            self.mid_curve = "%2.6f" % (self.args.get('a')*(float(self.X_k)**3)\
#                            + self.args.get('b') *(float(self.X_k)**2)\
#                         + self.args.get('c')*(float(self.X_k))+ self.args.get('d'))
#            count_2 +=1
#            total_2 += float(self.mid_curve)
#
#            print(count_2,'\t\t',"%2.2f" % self.X_k,'\t\t',self.mid_curve)
#
#        print('\t\t\t\t--------')
#        print('\t\t\t\t',total_2)
#        print('\t\t\t\t--------')
#        print('      midPoint Approximation =  %s' % (self.delta_X*total_2))
#
#    def ell_en(self,number):
#        """
#        Computing ellen(ln) Approximation  for a given value.
#        """
#
#        self.number = number
#
#        #attempt to Approximate In for a given value
#        try:
#            #Set RectangleMethod n and a fields to constant values
#            #and b field to a variable value, the greater n value the
#            # the more accurate result
#            rectangleMethod = RectangleMethod(n = 100000,a = 1, b=self.number)
#
#            sum_next = 0    #Set sum_next to 0
#
#            #inheriting and using midPoint function from Interval class
#            #to compute ln approximation.
#            for self.X_k in rectangleMethod.midPoint:
#
#                self.ell_en_X = 1/self.X_k
#                sum_next += self.ell_en_X
#                In = (sum_next * rectangleMethod.delta_X )
#                yield In
#
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("\n<The entered value is not a number")
#
#    def logarithm(self,base,value):
#        """
#        Computing logarithm approximation for a given value
#        and a base of choice
#        """
#
#        self.base = base
#        self.value = value
#
#        #attempt to Approximate logarithm for a given base and value
#        try:
#
#            for i in self.ell_en(self.value):
#                pass
#            for j in self.ell_en(self.base):
#                pass
#                result = round(i/j,8)
#
#          return "log_b%s(%s) = : %s " % (self.base,self.value,result)
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("\n<The entered value is not a number")
#
#    def exponential(self,value):
#        """
#        Compute exponential e and exp(value) for a given value
#        """
#
#        self.value = value
#
#        #attempt to yield an approximation of exp(n) for a given value
#        try:
#            for k in (1,100000000):
#                exp = ((1+1.0/k)**k)**value
#                yield exp
#
#            if self.value == 1:
#                print("e = %s " % repr(exp))
#            else:
#                print("exp(%s) = %s " % (value,repr(exp)))
#
#        #Raise TypeError if input is not numerical
#        except TypeError:
#            print("Please enter a number ")
#
```

#### Diff to Previous Revision

```--- revision 5 2011-01-19 12:36:37
+++ revision 6 2011-01-20 12:28:15
@@ -1,4 +1,5 @@
-#On the name of ALLAH
+#On the name of ALLAH and may the blessing and peace of Allah
+#be upon the Messenger of Allah Mohamed Salla Allahu Aliahi Wassalam.