8.Given this code://This a code to determine the root of a function//The function is (cosx+2)/3#include#includefloat root(float);int main(){float a[100],b[100],c=100.0;int i=1,j=0;b[0]=(cos(0)-3*0+1);printf("\nEnter a beginning guess:\n");scanf ("%f",&a[0]);while(c>0.00001){a[j+1]=root(a[j]);c=a[j+1]-a[j];c=fabs(c); //fabs = Absolute Value of Floating-Point Numberj++;}printf("\n The root of the given function is %f",a[j]);}float root(float x){ float y;y=(cos(x)+2)/3;return y;}Modify the code to demonstrate (print out, show) each of the values of the iterationbefore the final root is determined.

Answered: Modify the code to demonstrate (print…

Modify the code to demonstrate (print out, show) each of the values of the iteration before the final root is determined.

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

(Implement set operations in MyList)(JAVA) Please use class name: Exercise_01 The implementations of the methods addAll, removeAll, retainAll, toArray(), and toArray(T[]) are omitted in the MyList interface. Implement these methods. Test your new MyList class using the code at https://liveexample.pearsoncmg.com/test/Exercise24_01.txt. Sample Output: Enter five strings for array name1 separated by space: TomGeorgePeterJeanJaneEnter five strings for array name2 separated by space: TomGeorgeMichaelMichelleDanielEnter two strings for array name3 separated by space: TomPeterlist1:[Tom, George, Peter, Jean, Jane]list2:[Tom, George, Michael, Michelle, Daniel]After addAll:[Tom, George, Peter, Jean, Jane, Tom, George, Michael, Michelle, Daniel] list1:[Tom, George, Peter, Jean, Jane]list2:[Tom, George, Michael, Michelle, Daniel]After removeAll:[Peter, Jean, Jane] list1:[Tom, George, Peter, Jean, Jane]list2:[Tom, George, Michael, Michelle, Daniel]After retainAll:[Tom, George] list1:[Tom, George,…
Implement the logarithmBase22 method which, given a long integer number, returns the result of Logz2(number), rounded down to the nearest floor integer. Design and implement this as a recursive method. Read the test cases in the JUnit tester file for more detailed specification.
Please write your own code and put some commentary. Thank you
Do the trace in detail and submit The source Code As Well From the following recursive method Trace (in details) the calling of the above method with any input from your choice such that thereturned value will be 19. public static int think(int x) {if(x<10)if(x%2!=0)return x;elsereturn 0;elseif(x%2!=0)return x%10 + think(x/10);elsereturn think(x/10);}
Profile the performance of the memoized version of the Fibonacci function defined in Project 6. The function should count the number of recursive calls. State its computational complexity using big-O notation, and justify your answer. The fib function header has been modified to include the counter as the second parameter. Define the Counter class, it should have three methods: __init__, increment, and __str__. When an instance of the Counter class is passed as a parameter, the count property of that instance should be incremented based on the number of recursive calls. The __str__ method should return the count property's value as a string. ----------------------------------------------------------------------------------- """ File: fib.py Project 11.7 Employs memoization to improve the efficiency of recursive Fibonacci. Counts the calls and displays the results. """ class Counter(object): """Tracks a count.""" # Define the Counter class here. def fib(n, counter = None):…
I need the code from start to end with no errors and the explanation for the code ObjectivesJava refresher (including file I/O)Use recursionDescriptionFor this project, you get to write a maze solver. A maze is a two dimensional array of chars. Walls are represented as '#'s and ' ' are empty squares. The maze entrance is always in the first row, second column (and will always be an empty square). There will be zero or more exits along the outside perimeter. To be considered an exit, it must be reachable from the entrance. The entrance is not an exit.Here are some example mazes:mazeA7 9# # ###### # # ## # # #### # ## ##### ## ########## RequirementsWrite a MazeSolver class in Java. This program needs to prompt the user for a maze filename and then explore the maze. Display how many exits were found and the positions (not indices) of the valid exits. Your program can display the valid exits found in any order. See the examples below for exact output requirements. Also, record…
I have modified the code above. The input to test the method floydWarshal(graph,v) will come from the user (from the console through the scanner). v can not be a final variable because the user will determine the value of v. The double array graph will also be determined and input by the user (from the console through the scanner). I'm having issues getting the input from the user and putting it into the double array. I'm also having issues printing the result of the method, which should be the shortest path graph. Please help ------------------------------------------------------------------------------------ HERE IS THE CODE THAT I HAVE SO FAR import java.io.*;import java.util.*;import java.lang.*; public class Solution { final static int INF = 99999; public static void shortWarshall(int graph[][],int v) { int dist[][] = new int[v][v]; int i, j, k; /* Initialize the solution matrix same as input graph matrix. Or we can say the initial values of shortest distances are…
Note that you can only use recursion to solve Q1 and you cannot use any loop. You are free to add helper methods, but you are not allowed to change the method header.Question 1: Crazy seriesIn this session, you need to implement the crazy series method. In the crazy series, you will be given a starting number. Then, you need to times 2 for each number until the number is greater than 100. After the number is greater than 100, you need to divide 3 until we reach the number is less than 5. Note that the input number must be greater than 0, and you are not allowed to use loop here.For example,crazySeries(10) should return ArrayList [10.0, 20.0, 40.0, 80.0, 160.0, 53.333333333333336, 17.77777777777778, 5.9259259259259265, 1.9753086419753088]crazySeries(5) should return ArrayList [5.0, 10.0, 20.0, 40.0, 80.0, 160.0, 53.333333333333336, 17.77777777777778, 5.9259259259259265, 1.9753086419753088]crazySeries(1) should return ArrayList [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0,…
Below is the recursive implementation of binary search from lab with one change (in red): the print statement at the top of the function which prints "BOO" There is also a main function which calls bsearchR on the sorted array data[] with 7 elements and searching for 10. QUESTION: How many BOOS will be printed by this program? // Recursive Binary Search Routine that does the "Real" Work int bsearchR(int a[], int lo, int hi, int x) { int m; printf("BO0\n"); // <<<<==== NEW STATEMENT if(hi < lo) return -1; m = (lo + hi) / 2; if(a[m] == x) return m; else if(x < a[m]) return bsearchR(a, lo, m-1, x); else return bsearchR(a, m+1, hi, x); } int main() { int data[] = {5, 8, 12, 15, 20, 25, 30}; int idx = bsearchR(data, e, 6, 10); return 0; }
JAVA: Which is/are correct statement(s) about the Recursion? (Select all that apply) We can use for loop and while loop in recursion. We solve a problem that depends on solving smaller occurrences of the same problem. We have high performance while using recursion rather than iteration. We have high performance while using iteration rather than recursion. Easy to implement the algorithm while using recursion but hard to find the time complexity. Easy to implement the algorithm while using iteration but hard to find the time complexity. Base case is a simple occurrence that cannot be answered directly. Recursive case is a more complex occurrence of the problem that cannot be directly answered, but can instead be described in terms of smaller occurrences of the same problem. We must have exact one base case and one recursive case. We must have at least one base case. We must have at least one recursive case.