f(x) = 1/(1+25x?) This is a somewhat famous function in numerical analysis because it displays interesting behavior when approximated using polynomial interpolation on uniformly spaced nodes. You are going write your own code for polynomial interpolation and investigate the accuracy of two approximations. Task: Do the following: 1. Write a function that takes an array containing n +1 distinct points and returns the coefficients a, k 0, 1,...,n for the Newton form of the interpolating polynomial for an arbitrary function. You can pass in either the function f(x) or an array of function values at the points. 2. Write a function that takes the Newton coefficients of the polynomial and a point x and evaluates P(x). This should be the nested product form that is similar to Horner's method. 3. Write a program that calls your two functions to compute the interpolating polynomial for the specific function f(x) given above and does the following: (a) Using the 21 uniformly spaced nodes Xk = -1+ k(.1), k = 0, 1, ... , 20 have your program compute the error at r = .985 and also at r = 0.1. (b) Using 21 nodes given by 2k + 1 Ik = Cos k = 0, 1, ..., 20. 2(20+1) have your program compute the error at x = 0.985 and also at x = 0.1.

f(x) = 1/(1+25x?) This is a somewhat famous function in numerical analysis because it displays interesting behavior when approximated using polynomial interpolation on uniformly spaced nodes. You are going write your own code for polynomial interpolation and investigate the accuracy of two approximations. Task: Do the following: 1. Write a function that takes an array containing n +1 distinct points and returns the coefficients a, k 0, 1,...,n for the Newton form of the interpolating polynomial for an arbitrary function. You can pass in either the function f(x) or an array of function values at the points. 2. Write a function that takes the Newton coefficients of the polynomial and a point x and evaluates P(x). This should be the nested product form that is similar to Horner's method. 3. Write a program that calls your two functions to compute the interpolating polynomial for the specific function f(x) given above and does the following: (a) Using the 21 uniformly spaced nodes Xk = -1+ k(.1), k = 0, 1, ... , 20 have your program compute the error at r = .985 and also at r = 0.1. (b) Using 21 nodes given by 2k + 1 Ik = Cos k = 0, 1, ..., 20. 2(20+1) have your program compute the error at x = 0.985 and also at x = 0.1.

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 a function GetMinimumCutSegments(int[] arr, int k) that takes in an array arr of positive integers and an integer k, and returns the minimum number of contiguous segments of the array that must be concatenated to form an array of size k. The function should return -1 if it is not possible to create an array of size k by concatenating contiguous segments of the input array. Example: Input: [1, 2, 3, 4], 6 Output: 2 Explanation: The minimum number of contiguous segments that must be concatenated to form an array of size 6 is 2. The two segments that can be concatenated are [1, 2] and [3, 4]. Input: [1, 2, 3, 4], 7 Output: -1 Explanation: It is not possible to create an array of size 7 by concatenating contiguous segments of the input array. Constraints: The input array arr will have at most length 100. The integer k will be at least 1 and at most 10^6. Can you write a C# function that solves this problem? public int GetMinimumCutSegments(int[] arr, int k) { // Your code…
3) A function is implemented with a feature to print a line when x is found in the array A. def better_linear_search(A, x): for i in range(len(A)): if A[i] == x: print(x,"found at",i) return i return -1 What is the output after running code below? better_linear_search([17, 2, 10, 3], 10) better_linear_search([0, 9, 9, 9], 18) better_linear_search([12, 8, 7, 8], 8).
Write a function: diceSim(D1,D2,trials) that takes as input the number of sides on die 1 (D1) and die2 (D2) and the number of trials. Your function should repeatedly sum pairs of random numbers between 1 and D1 and 1 and D2 and keep track of how many times each sum occurs. The function returns a numpy array with the fraction each sum of rolls occured. Since the numbers are chosen at random, the fractions will differ some from run to run. One run of the function print(p22.diceSim(6,6,10000)) resulted in: [0. 0. 0.0259 0.0615 0.0791 0.1086 0.139 0.1633 0.1385 0.114 0.0833 0.0587 0.0281]
Write a function that returns an integer that appears most often with respect to an array of integers In the array. for example. [1 2 3 2 3 4 2 5] For an array your function must return 2.
Write a function my_min(L) that takes an array L of real numbers or integers and returns the smallest value in the array. Write the function "from scratch", without using any min function defined in the python libraries. Test your function on the array A below and show the result. A = [12, 45, 23, 22, 42, 15, 17, 15, 73, 36, 7, 13, 38, 43, 53, 86, 40, 45, 63, 74]
) Write a program to overload the function call operator ( ) so as to allow the more common form of double-array subscripting. Therefore, instead of saying: chessBoard[row][column] for an array of objects, overload the function call operator to allow the alternate form: chessBoard(row, column) A sample output of your program should look like follows: chessBoard(1, 7) is 7 chessBoard(3, 5) is 15 chessBoard(8, 2) is 16 The value of each array element is the product of the row and column values. Using the class definition given in the myClassOperator.h header file below, implement the class member functions and driver code in separate files.
Suppose you are given an array of integers and a target sum. Write a function that finds all pairs of integers in the array that add up to the target sum. Your function should return an array of arrays, where each inner array contains two integers that add up to the target sum. You may assume that the input array is not empty and that all elements are unique. For example, if the input array is [3, 5, 2, -4, 8, 11] and the target sum is 7, your function shou return [[3, 4], [2, 5], [-4, 11]]. Solve it in C# language
Write a function is ordered that takes an integer array and its size as parameters and returns true if the array elements are ordered in nondecreasing order and returns false if not. For example, integers in {10,0,1,1,5,1009} are ordered in nondecreasing order. On the other hand, integers in {1, 2, 3, 8, 4, 19} are not since 8 > 4
C++ We have an array (x) of ints: x = {6,2,3,1,6,1,1,7,8} We would like to write a void function, call it newArray, that will update the array so that an element of the array is updated by subtracting the first item to its right that is equal to or less than that element. For example, x = {6,2,3,1,6,1,1,7,8] becomes x{4,1,2,0,5,0,1,7,8} Print the updated array, the sum of the array, and a list of the positions of the items that are not updated. *think of nested loops and the use of the break statement where appropriate
please code in python def isEverywhere(nums, val): #complete the function We'll say thatt a value is "everywhere" in an array if for every pair of adjacent elements in the array, at least one of the pair is that value. Return true if the given value is everywhere in the array. Example: isEverywhere([1,2,1,3],1) -> trueisEverywhere([1,2,1,3],2) -> falseisEverywhere([1,2,1,3,4],1) -> false
Prompt: In Python language, write a function that applies the logistic sigmoid function to all elements of a NumPy array. Code: import numpy as np import math import matplotlib.pyplot as plt import pandas as pd def sigmoid(inputArray): modifiedArray = np.zeros(len(inputArray)) #YOUR CODE HERE: return(modifiedArray) def test(): inputs = np.arange(-100, 100, 0.5) outputs = sigmoid(inputs) plt.figure(1) plt.plot(inputs) plt.title('Input') plt.xlabel('Index') plt.ylabel('Value') plt.show() plt.figure(2) plt.plot(outputs,'Black') plt.title('Output') plt.xlabel('Index') plt.ylabel('Value') plt.show() test()
3. Implement a function called findLargestIndex which returns the index of the rowwith the largest sum.ex. int array[3][6] = {{3, 6, 8, 2, 4, 1}, // sum = 24{2, 4, 5, 1, 3, 4}, // sum = 19{1, 0, 9, 0, 1, 0}}; // sum = 11If the findLargestIndex function was called using this array, it would return 0, asit is returning the index of the row, not the sum.Note that the number of columns is required when passing a 2d array to a function.Assume that 2D arrays passed to this function will have 6 columns.Title line: int findLargestIndex(int array[][6], int rows, int columns);