Assignment 3 CSCE 155H/RAIK 183H Fall 2016

Transcription

1 Assignment 3 CSCE 155H/RAIK 183H Fall 2016 Instructions Follow instructions carefully, failure to do so may result in points being deducted. Hand in all your source code files through webhandin and make sure your programs compile and run by using the webgrader interface. You can grade yourself and re-handin as many times as you wish up until the due date. Print a hardcopy of the rubric for this assignment and hand it in by the due date. Partner Policy You may work in pairs for this assignment if you chose. If you do work in any groups or pairs, you must follow these guidelines: 1. You must work on all problems together. You may not simply partition the work between you. 2. You should not discuss problem details with other groups or individuals beyond general questions. 3. Hand in only one hard copy (and one soft copy) under the first author s name/cse login. Be sure to include both names. Programs 1. In this exercise you will build a small library of several utility functions by implementing the following functions with the given prototypes and specified functionality. 1 int circlestatistics(double radius, double *diameter, 2 double *circumference, double *area) implement this function to compute common values regarding a circle given its radius. The function should place the specified values in the variables passed by reference. The return value should indicate an error code: 0 for no error, 1 for any type of error (negative radius, NULL pointers). int converttime(int days, int *y, int *w, int *d) This function takes a number of days and converts it to years, y, (ignore leap year days), weeks w, and (remaining) days d and places the three results in the variables provided. The function returns 0 for no error and 1 if any of the inputs are invalid (days is negative or any of the pointers are NULL ). 1 int lorentztimedilation(double normaltime, 2 double percentc, double *dilatedtime) An object traveling at a velocity v experiences a dilated time relative to a stationary object which is quantified by the Lorentz equation: T = t (1 v2 ) c 2

2 where t is the normal amount of lapsed time (stationary object) and T is the dilated time experienced by the traveling object. For small velocities, the dilation is small, but for velocities approaching a percentage of the speed of light, c, the dilation becomes significant. At 25% the speed of light, a year for the object traveling would correspond to years at the stationary object. Implement the function to compute the dilated time given the normal time t and the percentage of the speed of light, placing the result in the third argument. The function should return 0 for no error and 1 for invalid inputs (negative normal time, percentages outside of the range [0, 1), or a NULL pointer). double agm(double x, double y, double epsilon) The arithmetic-geometric mean of two numbers x, y, denoted M(x, y) (or agm(x, y)) can be computed iteratively as follows. Initially, a 1 = 1 2 (x + y) and g 1 = xy (i.e. the normal arithmetic and geometric means). Then, compute a n+1 = 1 2 (a n + g n ) g n+1 = a n g n The two sequences will converge to the same number which is the arithmeticgeometric mean of x, y. Obviously we cannot compute an infinite sequence, so we compute until a n g n < ɛ for some small number ɛ. Place all of your function prototypes into a file named utils.h and and their definitions in a file named utils.c. In addition, create a main test driver program that demonstrates at least 3 test calls to each of your functions to verify that their output matches your expected output. You should not prompt for input; rather your test cases should be hardcoded in your test driver s main function. Place your main function into a file named utilstester.c. Hand in all three of your source files using webhandin. 2. The standard math library ( math.h ) provides a function to compute the natural logarithm ln(x) ( log ) of a number x. In this exercise, we ll be writing several of our own functions to compute the natural logarithm. root of a given number. In particular, you will implement the following methods to compute ln(x). A formula version approximates the natural logarithm as: π ln(x) 2M(1, 4/s) m ln(2) Where M(a, b) is the arithmetic-geometric mean and s = x2 m. In this formula, m is a parameter (a larger m provides more precision). Use this method in a function with the following signature: int lnformula(double x, int m, double *result) The standard Taylor Series for the natural logarithm is: ( 1) n+1 ln(x) = (x 1) n n n=1 Page 2

3 As we cannot compute an infinite series, we will simply compute the series to the first m terms. Also note that this series is not convergent for values x > 1 Use this method in a function with the following signature: int lntaylorseries(double x, int m, double *result) Borchardt s algorithm is an iterative method that works as follows. Let Then repeat: a 0 = 1 + x 2 b 0 = x a k+1 = a k+b k 2 b k+1 = a k+1 b k until the absolute difference between a k, b k is small; that is a k b k < ɛ. Then the logarithm is approximated as ln(x) 2 x 1 a k + b k Use this method in a function with the following signature: int lnborchardt(double x, double epsilon, double *result) Newton s method works if x is sufficiently close to 1. It works by setting y 0 = 1 and then computing y n+1 = y n + 2 x eyn x + e yn The iteration is performed m times. To ensure this method works, you need to modify x to be as close to possible to 1. One way to do this is to divide or multiply by e until x is close to 1. Suppose we divided by e k times; that is x = z e k where z is close to 1. Then ln(x) = ln(z e k ) = ln(z) + ln(e k ) = ln(z) + k Thus, we can apply Newton s method to z and add k to the result to get ln(x). Use this method in a function with the following signature: int lnnewton(double x, int m, double *result) In addition, do the following: Place your function prototypes in a file named mylog.h and function definitions in a file named mylog.c Each function should compute the approximation of ln (x) and place it in the variable result which is passed by reference Each function should return an integer to indicate an error-level: 0 for no error, a non-zero value for error conditions. Error conditions would include non-positive values of x, invalid parameters (ɛ 0, m < 1) or NULL pointer values. Page 3

4 Write a main driver program to demonstrate (and test) your functions. Place your main function in a file named lndemo.c and have it read a collection of floating point numbers via command line arguments and compute their natural logarithms using each of the methods as well as the standard log method and compute the errors of each. For the purposes of this demo, fix ɛ = and m = 8 for the parameters above. That is, your program should be runnable from the command line as: ~>./a.out which should produce output something like: x math.h Formula Taylor Borchadt Newton Hand in all three of your source files using webhandin. To help you with Newton s method, the following code snippet will scale a variable x by e to the smallest value greater than 1. 1 int k = 0; 2 double scaled_x = x; 3 while(scaled_x < 1.0) { 4 scaled_x *= M_E; 5 k--; 6 } 7 while( (scaled_x / M_E) > 1.0) { 8 scaled_x /= M_E; 9 k++; 10 } 3. Energy can be measured in several different scales: calories (c), joules (J), ergs (erg) and foot-pound force (ft-lbf) among others. To convert between these scales, you can use the following facts: 1 erg equals J 1 ft-lbs equals joules 1 calorie is equal to joules You could write several functions to compute back and forth between these four scales. However, for this exercise, you will write a single function to convert a single value to all four at once. Specifically you will implement the following function: 1 int convertenergy(double *cals, 2 double *joules, 3 double *ergs, 4 double *ftlbf, 5 Scale scale); Page 4

5 Note: You will need to define an enumerated type called Scale that has four values: CALORIE, JOULE, ERG, FTLBF, the value passed to the function will serve as a flag to indicate which scale the conversion is from; the value stored in the corresponding variable should be used convert to the remaining three. The return value will be a flag indicating an error-level: 0 for no error, otherwise a non-zero value for various types of errors (negative energy values, null pointers, invalid scales, etc.). You are encouraged to define another Error enumerated type for this purpose. Place your enum declaration and the prototype declaration in a file called energy.h Place your actual function implementation in a file called energy.c Create a main function in energydemo.c that prompts the user for one of the scales (an integer 1 4 in the order listed above) and a value to convert and outputs the result of all four scales (or indicates an appropriate error message). 4. Reimplement the natural logarithm methods in Java with the following changes (a Java source file, MyLog.java has been provided to get you started). All methods should be public static The return value should be the computed natural logarithm rather than an error code All input values should be their wrapper classes to allow for null For invalid inputs throw appropriate exceptions instead: IllegalArgumentException or NullPointerException You should implement a test driver program but you do not need to hand it in. Place all of your classes in a package named unl.cse 5. Reimplement the energy conversion method in Java. As Java does not have pointers and the basic wrapper classes ( Double, Integer ) are immutable, you cannot pass in multiple variables. Instead, implement the method with the following signature: 1 public static double convertenergy( 2 Double v, 3 Scale inputscale, 4 Scale outputscale) Where Scale is an enumerated type with the same four scales. The method should convert the input value v which is in the inputscale to the outputscale and return the result. In addition, do the following: Page 5

6 Place your method in a class named EnergyUtils Create your Scale enumerated class with the same values as before. Create an exception class named InvalidEnergyException and throw it for any inputs that are invalid (negative energy values). Note that all the method signatures allow a Double ; be sure to handle the case when null is passed appropriately You should implement a test driver program but you do not need to hand it in. Place all of your classes in a package named unl.cse Page 6