Python! please

Project Program requirements:

$$Implement named constants, with correct naming convention, for the

constants to determine the output of the range method

$$Generate a list of multiples of $5$ in the range $[5,5000]$

$$Implement the Newton$-$Raphson algorithm and the Bisection search

algorithms to compute the square roots

$$ Set epsilon at $0\mathrm{.}01$ for both algorithms

$$ Determine the following for each algorithm:

$$ Max, min and average number of iterations required

$$Determine the execution time for each algorithm

$$Plot histograms, in the same figure, of the number of iterations

required by each algorithm

To solve Project $2,$ do the following:

$$Modify the code below as follows:

$$ Add code to implement the Newton$-$Raphson algorithm to compute square roots $($code can be found in Figure $3-7$ page $61$ of the text$)$

$$ Determine execution time

$$ Determine number of iterations required

$$ Verify that your code produces output similar to the sample output that you$$ve been given in the next slide

$`````````````````````````````````````$

#import package needed to compute execution time

import time

#import matplotlib to enable plotting histogram

import matplotlib.pyplot as plt

#lab $2$ solution

#First generate a series of numbers, for which to compute square root

#constants to determine start, stopPlusOneStep, step vallue for range function

START$\_$VAL $=5$

#NOTE: the STOP$\_$VAL is one STEP$\_$VAL beyond the last number generated

STOP$\_$VAL $=5005$

STEP$\_$VAL $=$ START$\_$VAL

#first create an empty list:

nums $=[]$

#generate all multiples of $5$ from $5$ to $5000,$ inclusive

for i in range$($START$\_$VAL, STOP$\_$VAL, STEP$\_$VAL$)$:

#append each new number to the nums list

nums.append$($i$)$

#create an empty list for the square roots computed using bisection search

bis$\_$ans $=[]$

#create an empty list for the number of iterations required using bisection search

bis$\_$num$\_$it $=[]$

#set the desired value of epsilon

epsilon $=0\mathrm{.}01$

#implement bisection search to compute square root of all the numbers in the nums list

#determined the start time at which bisection search started

bis$\_$start$\_$time $=$ time.time$()$

#use for loop to iterate through all numbers, computing for each the square root using bisection search

for i in range$($len$($nums$))$:

#begin assigning elements to the list keeping track of number of iterations required

#each element begins with zero, which will be successively incremented by one with each iteration

bis$\_$num$\_$it$.$append$(0)$

#initialize variables needed for bisection search

low $=0\mathrm{.}0$

high $=$ max$(1\mathrm{.}0,$ nums$[$i$])$

ans $=($high $+$ low$)/2\mathrm{.}0$

#iterate the bisection search method until the estimated square root is within epsilon of correct value

while abs$($ans$**2-$ nums$[$i$])>=$ epsilon:

#increment by one this element of the bisNumIt list

bis$\_$num$\_$it$[$i$]+=1$

#determine in which half of the search space the correct answer

if ans$**2<$ nums$[$i$]$:

low $=$ ans

else:

high $=$ ans

#now that the correct area of search space located, update the estimate of the square root$($i$.$e ans$)$

ans $=($high $+$ low$)/2$

#when the diff between the estimate and the correct answer is less than epsilon, append this to the bis$\_$ans list

bis$\_$ans.append$($ans$)$

#determine the time at which the bisection search was completed

bis$\_$end$\_$time $=$ time.time$()$

#compute the execution time required to execute bisection search

bis$\_$exe$\_$time $=$ bis$\_$end$\_$time $-$ bis$\_$start$\_$time

#determine ave number of iterations

sum$\_$iterations $=0$

for i in range$($len$($bis$\_$num$\_$it$))$:

sum$\_$iterations $+=$ bis$\_$num$\_$it$[$i$]$

ave$\_$iterations $=$ sum$\_$iterations$/$len$($bis$\_$num$\_$it$)$

#display results for bisection search

print$(\text{'}$Use bisection search algorithm to compute square roots of multiples of$\text{'},$ STEP$\_$VAL,$\text{'}$in the following range:$\text{'})$

print$(\text{'}[\text{'},$ START$\_$VAL,$\text{'},\text{'},($STOP$\_$VAL $-$ STEP$\_$VAL$),\text{'}]\text{'})$

print$(\text{'}$Max num iterations required:$\text{'},$ max$($bis$\_$num$\_$it$))$

print$(\text{'}$Min num iterations required:$\text{'},$ min$($bis$\_$num$\_$it$))$

#average number of iterations, rounded to four places

print$(\text{'}$Ave number of iterations required:$\text{'},$ round$($ave$\_$iterations,$4))$

#execute time rounded to six places

print$(\text{'}$Bisection search execution time:$\text{'},$f$\text{'}\{$bis$\_$exe$\_$time:$\mathrm{.}6$f$\}\text{'})$

print$(\text{'}***************************************\text{'})$

#plot histogram illustrating number iterations required for bisection search

#set up number of 'bins'

bins $=10$

#histogram of bis$\_$num$\_$it list

plt$.$hist$($bis$\_$num$\_$it$,$ bins,facecolor$=$'green',label $=$ 'bis$\_$num$\_$it$\text{'})$

#formoat features of the histogram

plt$.$legend$($loc $=$ 'upper left'$)$

plt$.$xlabel$(\text{'}$Number of iterations required'$)$

plt$.$ylabel$(\text{'}$Num occurences of each iteration value'$)$

plt$.$title$(\text{'}$Histogram Illustrating Number of Iterations: Bisection Search'$)$

my code is giving me $3$ iterations for Netwon raphson instead of $2,$ please help