global total_tests, total_exceptions: mstart := trunc(time()*1000.0): rstart := 1429039422*1000: rcpuustart := 1.093*1000: rcpusstart := 0.015*1000: total_tests := 0: total_exceptions := 0: hours_elapsed := proc(msec) local hrs: hrs := trunc(evalf(msec/3600000)): hrs : end: min_elapsed := proc(hrs,msec) local min2: min2 := trunc(evalf((msec-hrs*3600000)/60000)): min2: end: sec_elapsed := proc(hrs,min2,msec) local sec2: sec2 := trunc(evalf((msec - hrs*360000 - min2 * 60000)/1000)) : sec2 : end: msec_elapsed := proc(hrs,min2,sec2,msec) local msec2: msec2 := msec - hrs*3600000 - min2 * 60000 - sec2 * 1000: msec2 : end: dump_except := proc(opname,x,y,fxm,fxr,fxrerr,percent_error,abs_error,except_fd,differentialm,x_start_err,_y_start_err) global total_tests, total_exceptions; total_exceptions := total_exceptions + 1; fprintf(except_fd,"EXCEPTION: Operator = %s \n",opname); fprintf(except_fd,"x = %40.34e\n",x); fprintf(except_fd,"error given in x = %40.34e\n",x_start_err); fprintf(except_fd,"y = %40.34e\n",y); fprintf(except_fd,"error given in y = %40.34e\n",y_start_err); fprintf(except_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(except_fd,"Maple value = %40.34e\n",fxm): fprintf(except_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(except_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(except_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(except_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(except_fd,"___________________________________________________________________\n"): end: out_fd := fopen(`apoptst.txt`,WRITE,TEXT): except_fd := fopen(`apopexcept.txt`,WRITE,TEXT): fprintf(except_fd,"___________________________________________________________________\n"): Digits := 34: fprintf(out_fd,"Operator = addition\n"): fprintf(except_fd,"Operator = addition\n"): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -6.0; fxm := (-6.0)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.12e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -5.1; fxm := (-6.0)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.111e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -4.199999999999999; fxm := (-6.0)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.10199999999999999e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -3.2999999999999994; fxm := (-6.0)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.92999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -2.3999999999999995; fxm := (-6.0)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.83999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -1.4999999999999996; fxm := (-6.0)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.74999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := -0.5999999999999995; fxm := (-6.0)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.65999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 0.3000000000000005; fxm := (-6.0)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.56999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 1.2000000000000006; fxm := (-6.0)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.47999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 2.1000000000000005; fxm := (-6.0)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.38999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 3.0000000000000004; fxm := (-6.0)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.29999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 3.9000000000000004; fxm := (-6.0)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.20999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 4.800000000000001; fxm := (-6.0)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.1199999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -6.0; y := 5.700000000000001; fxm := (-6.0)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.299999999999999e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-6.0,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -6.0; fxm := (-5.2)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.112e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -5.1; fxm := (-5.2)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.103e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -4.199999999999999; fxm := (-5.2)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.9399999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -3.2999999999999994; fxm := (-5.2)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.84999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -2.3999999999999995; fxm := (-5.2)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.75999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -1.4999999999999996; fxm := (-5.2)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.66999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := -0.5999999999999995; fxm := (-5.2)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.57999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 0.3000000000000005; fxm := (-5.2)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.48999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 1.2000000000000006; fxm := (-5.2)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.39999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 2.1000000000000005; fxm := (-5.2)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.30999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 3.0000000000000004; fxm := (-5.2)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.21999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 3.9000000000000004; fxm := (-5.2)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.12999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 4.800000000000001; fxm := (-5.2)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.399999999999999e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -5.2; y := 5.700000000000001; fxm := (-5.2)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.500000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-5.2,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -6.0; fxm := (-4.4)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.104e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -5.1; fxm := (-4.4)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.95e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -4.199999999999999; fxm := (-4.4)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.8599999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -3.2999999999999994; fxm := (-4.4)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.76999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -2.3999999999999995; fxm := (-4.4)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.67999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -1.4999999999999996; fxm := (-4.4)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.58999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := -0.5999999999999995; fxm := (-4.4)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.49999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 0.3000000000000005; fxm := (-4.4)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.40999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 1.2000000000000006; fxm := (-4.4)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.31999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 2.1000000000000005; fxm := (-4.4)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.22999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 3.0000000000000004; fxm := (-4.4)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.13999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 3.9000000000000004; fxm := (-4.4)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.4999999999999996e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 4.800000000000001; fxm := (-4.4)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.400000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -4.4; y := 5.700000000000001; fxm := (-4.4)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.1300000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-4.4,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -6.0; fxm := (-3.6000000000000005)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.96000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -5.1; fxm := (-3.6000000000000005)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.87000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -4.199999999999999; fxm := (-3.6000000000000005)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.77999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -3.2999999999999994; fxm := (-3.6000000000000005)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.68999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -2.3999999999999995; fxm := (-3.6000000000000005)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.6e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -1.4999999999999996; fxm := (-3.6000000000000005)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.51000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -0.5999999999999995; fxm := (-3.6000000000000005)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.42e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 0.3000000000000005; fxm := (-3.6000000000000005)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.33e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 1.2000000000000006; fxm := (-3.6000000000000005)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.23999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 2.1000000000000005; fxm := (-3.6000000000000005)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.15e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.0000000000000004; fxm := (-3.6000000000000005)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.6000000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.9000000000000004; fxm := (-3.6000000000000005)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.2999999999999999e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 4.800000000000001; fxm := (-3.6000000000000005)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.12000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 5.700000000000001; fxm := (-3.6000000000000005)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.21000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-3.6000000000000005,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -6.0; fxm := (-2.8000000000000007)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.88000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -5.1; fxm := (-2.8000000000000007)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.79000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -4.199999999999999; fxm := (-2.8000000000000007)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.69999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -3.2999999999999994; fxm := (-2.8000000000000007)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.61000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -2.3999999999999995; fxm := (-2.8000000000000007)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.52000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -1.4999999999999996; fxm := (-2.8000000000000007)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.43000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -0.5999999999999995; fxm := (-2.8000000000000007)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.34000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 0.3000000000000005; fxm := (-2.8000000000000007)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.25000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 1.2000000000000006; fxm := (-2.8000000000000007)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.16000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 2.1000000000000005; fxm := (-2.8000000000000007)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.7000000000000002e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.0000000000000004; fxm := (-2.8000000000000007)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.1999999999999997e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.9000000000000004; fxm := (-2.8000000000000007)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.10999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 4.800000000000001; fxm := (-2.8000000000000007)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.20000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 5.700000000000001; fxm := (-2.8000000000000007)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.29000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.8000000000000007,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -6.0; fxm := (-2.000000000000001)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.8000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -5.1; fxm := (-2.000000000000001)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.7100000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -4.199999999999999; fxm := (-2.000000000000001)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.62e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -3.2999999999999994; fxm := (-2.000000000000001)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.53000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -2.3999999999999995; fxm := (-2.000000000000001)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.44000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -1.4999999999999996; fxm := (-2.000000000000001)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.35000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -0.5999999999999995; fxm := (-2.000000000000001)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.26000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 0.3000000000000005; fxm := (-2.000000000000001)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.17000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 1.2000000000000006; fxm := (-2.000000000000001)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.8000000000000004e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 2.1000000000000005; fxm := (-2.000000000000001)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.999999999999995e-1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.0000000000000004; fxm := (-2.000000000000001)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.9999999999999994e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.9000000000000004; fxm := (-2.000000000000001)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.18999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 4.800000000000001; fxm := (-2.000000000000001)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.28e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 5.700000000000001; fxm := (-2.000000000000001)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.37e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-2.000000000000001,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -6.0; fxm := (-1.2000000000000008)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.72000000000000008e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -5.1; fxm := (-1.2000000000000008)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.63000000000000008e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -4.199999999999999; fxm := (-1.2000000000000008)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.53999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -3.2999999999999994; fxm := (-1.2000000000000008)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.45000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -2.3999999999999995; fxm := (-1.2000000000000008)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.36000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -1.4999999999999996; fxm := (-1.2000000000000008)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.27000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -0.5999999999999995; fxm := (-1.2000000000000008)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.18000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 0.3000000000000005; fxm := (-1.2000000000000008)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.9000000000000003e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 1.2000000000000006; fxm := (-1.2000000000000008)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.2e-15; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 2.1000000000000005; fxm := (-1.2000000000000008)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.8999999999999997e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.0000000000000004; fxm := (-1.2000000000000008)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.17999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.9000000000000004; fxm := (-1.2000000000000008)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.26999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 4.800000000000001; fxm := (-1.2000000000000008)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.36000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 5.700000000000001; fxm := (-1.2000000000000008)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.45000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-1.2000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -6.0; fxm := (-0.4000000000000008)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.64000000000000008e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -5.1; fxm := (-0.4000000000000008)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.55000000000000008e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -4.199999999999999; fxm := (-0.4000000000000008)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.45999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -3.2999999999999994; fxm := (-0.4000000000000008)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.37000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -2.3999999999999995; fxm := (-0.4000000000000008)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.28000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -1.4999999999999996; fxm := (-0.4000000000000008)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.19000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -0.5999999999999995; fxm := (-0.4000000000000008)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.10000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 0.3000000000000005; fxm := (-0.4000000000000008)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.1000000000000003e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 1.2000000000000006; fxm := (-0.4000000000000008)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.7999999999999998e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 2.1000000000000005; fxm := (-0.4000000000000008)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.16999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.0000000000000004; fxm := (-0.4000000000000008)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.25999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.9000000000000004; fxm := (-0.4000000000000008)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.34999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 4.800000000000001; fxm := (-0.4000000000000008)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.44000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 5.700000000000001; fxm := (-0.4000000000000008)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.53000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,-0.4000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -6.0; fxm := (0.39999999999999925)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.560000000000000075e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -5.1; fxm := (0.39999999999999925)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.470000000000000075e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -4.199999999999999; fxm := (0.39999999999999925)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.379999999999999975e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -3.2999999999999994; fxm := (0.39999999999999925)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.290000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -2.3999999999999995; fxm := (0.39999999999999925)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.200000000000000025e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -1.4999999999999996; fxm := (0.39999999999999925)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.110000000000000035e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -0.5999999999999995; fxm := (0.39999999999999925)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.20000000000000025e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 0.3000000000000005; fxm := (0.39999999999999925)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.69999999999999975e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 1.2000000000000006; fxm := (0.39999999999999925)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.159999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 2.1000000000000005; fxm := (0.39999999999999925)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.249999999999999975e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.0000000000000004; fxm := (0.39999999999999925)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.339999999999999965e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.9000000000000004; fxm := (0.39999999999999925)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.429999999999999965e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 4.800000000000001; fxm := (0.39999999999999925)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.520000000000000025e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 5.700000000000001; fxm := (0.39999999999999925)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.610000000000000025e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,0.39999999999999925,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -6.0; fxm := (1.1999999999999993)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.48000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -5.1; fxm := (1.1999999999999993)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.39000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -4.199999999999999; fxm := (1.1999999999999993)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.29999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -3.2999999999999994; fxm := (1.1999999999999993)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.21000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -2.3999999999999995; fxm := (1.1999999999999993)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.12000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -1.4999999999999996; fxm := (1.1999999999999993)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.3000000000000003e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -0.5999999999999995; fxm := (1.1999999999999993)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.5999999999999998e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 0.3000000000000005; fxm := (1.1999999999999993)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.14999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 1.2000000000000006; fxm := (1.1999999999999993)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.23999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 2.1000000000000005; fxm := (1.1999999999999993)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.32999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.0000000000000004; fxm := (1.1999999999999993)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.41999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.9000000000000004; fxm := (1.1999999999999993)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.50999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 4.800000000000001; fxm := (1.1999999999999993)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.60000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 5.700000000000001; fxm := (1.1999999999999993)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.69000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.1999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -6.0; fxm := (1.9999999999999993)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.40000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -5.1; fxm := (1.9999999999999993)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.31000000000000007e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -4.199999999999999; fxm := (1.9999999999999993)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.21999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -3.2999999999999994; fxm := (1.9999999999999993)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.13000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -2.3999999999999995; fxm := (1.9999999999999993)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.4000000000000002e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -1.4999999999999996; fxm := (1.9999999999999993)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.4999999999999997e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -0.5999999999999995; fxm := (1.9999999999999993)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.13999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 0.3000000000000005; fxm := (1.9999999999999993)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.22999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 1.2000000000000006; fxm := (1.9999999999999993)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.31999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 2.1000000000000005; fxm := (1.9999999999999993)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.40999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.0000000000000004; fxm := (1.9999999999999993)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.49999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.9000000000000004; fxm := (1.9999999999999993)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.58999999999999997e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 4.800000000000001; fxm := (1.9999999999999993)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.68000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 5.700000000000001; fxm := (1.9999999999999993)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.77000000000000003e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,1.9999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -6.0; fxm := (2.7999999999999994)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.32000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -5.1; fxm := (2.7999999999999994)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.23000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -4.199999999999999; fxm := (2.7999999999999994)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.13999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -3.2999999999999994; fxm := (2.7999999999999994)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.5e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -2.3999999999999995; fxm := (2.7999999999999994)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.3999999999999999e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -1.4999999999999996; fxm := (2.7999999999999994)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.12999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -0.5999999999999995; fxm := (2.7999999999999994)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.21999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 0.3000000000000005; fxm := (2.7999999999999994)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.30999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 1.2000000000000006; fxm := (2.7999999999999994)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.4e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 2.1000000000000005; fxm := (2.7999999999999994)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.48999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.0000000000000004; fxm := (2.7999999999999994)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.57999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.9000000000000004; fxm := (2.7999999999999994)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.66999999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 4.800000000000001; fxm := (2.7999999999999994)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.76000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 5.700000000000001; fxm := (2.7999999999999994)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.85000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,2.7999999999999994,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -6.0; fxm := (3.5999999999999996)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.24000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -5.1; fxm := (3.5999999999999996)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.15000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -4.199999999999999; fxm := (3.5999999999999996)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.5999999999999994e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -3.2999999999999994; fxm := (3.5999999999999996)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.3000000000000002e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -2.3999999999999995; fxm := (3.5999999999999996)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.12000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -1.4999999999999996; fxm := (3.5999999999999996)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.21e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -0.5999999999999995; fxm := (3.5999999999999996)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.30000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 0.3000000000000005; fxm := (3.5999999999999996)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.39000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 1.2000000000000006; fxm := (3.5999999999999996)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.48000000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 2.1000000000000005; fxm := (3.5999999999999996)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.57000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.0000000000000004; fxm := (3.5999999999999996)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.66e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.9000000000000004; fxm := (3.5999999999999996)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.75e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 4.800000000000001; fxm := (3.5999999999999996)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.84000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 5.700000000000001; fxm := (3.5999999999999996)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.93000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,3.5999999999999996,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -6.0; fxm := (4.3999999999999995)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.16000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -5.1; fxm := (4.3999999999999995)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.7000000000000005e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -4.199999999999999; fxm := (4.3999999999999995)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.2000000000000005e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -3.2999999999999994; fxm := (4.3999999999999995)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.11000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -2.3999999999999995; fxm := (4.3999999999999995)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.2e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -1.4999999999999996; fxm := (4.3999999999999995)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.28999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -0.5999999999999995; fxm := (4.3999999999999995)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.38e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 0.3000000000000005; fxm := (4.3999999999999995)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.47e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 1.2000000000000006; fxm := (4.3999999999999995)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.56000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 2.1000000000000005; fxm := (4.3999999999999995)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.65e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.0000000000000004; fxm := (4.3999999999999995)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.73999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.9000000000000004; fxm := (4.3999999999999995)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.82999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 4.800000000000001; fxm := (4.3999999999999995)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.92000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 5.700000000000001; fxm := (4.3999999999999995)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.101000000000000005e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,4.3999999999999995,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -6.0; fxm := (5.199999999999999)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.800000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -5.1; fxm := (5.199999999999999)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.99999999999999e-1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -4.199999999999999; fxm := (5.199999999999999)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.1e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -3.2999999999999994; fxm := (5.199999999999999)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.18999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -2.3999999999999995; fxm := (5.199999999999999)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.27999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -1.4999999999999996; fxm := (5.199999999999999)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.36999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -0.5999999999999995; fxm := (5.199999999999999)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.45999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 0.3000000000000005; fxm := (5.199999999999999)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.54999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 1.2000000000000006; fxm := (5.199999999999999)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.63999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 2.1000000000000005; fxm := (5.199999999999999)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.72999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.0000000000000004; fxm := (5.199999999999999)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.81999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.9000000000000004; fxm := (5.199999999999999)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.90999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 4.800000000000001; fxm := (5.199999999999999)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.1e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 5.700000000000001; fxm := (5.199999999999999)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.109e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.199999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -6.0; fxm := (5.999999999999999)+(-6.0); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.1e-14; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -5.1; fxm := (5.999999999999999)+(-5.1); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.899999999999999e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -4.199999999999999; fxm := (5.999999999999999)+(-4.199999999999999); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.18e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -3.2999999999999994; fxm := (5.999999999999999)+(-3.2999999999999994); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.26999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -2.3999999999999995; fxm := (5.999999999999999)+(-2.3999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.35999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -1.4999999999999996; fxm := (5.999999999999999)+(-1.4999999999999996); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.44999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -0.5999999999999995; fxm := (5.999999999999999)+(-0.5999999999999995); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.53999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 0.3000000000000005; fxm := (5.999999999999999)+(0.3000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.62999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 1.2000000000000006; fxm := (5.999999999999999)+(1.2000000000000006); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.71999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 2.1000000000000005; fxm := (5.999999999999999)+(2.1000000000000005); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.80999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.0000000000000004; fxm := (5.999999999999999)+(3.0000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.89999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.9000000000000004; fxm := (5.999999999999999)+(3.9000000000000004); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.98999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 4.800000000000001; fxm := (5.999999999999999)+(4.800000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.108e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = addition \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 5.700000000000001; fxm := (5.999999999999999)+(5.700000000000001); fffx := x -> x +y; fffy := y -> x +y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.117e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(addition,5.999999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(out_fd,"Operator = subtraction\n"): fprintf(except_fd,"Operator = subtraction\n"): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -6.0; fxm := (-6.0)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.0e0; fxrerr := 0.10000001e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -5.1; fxm := (-6.0)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.9e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -4.199999999999999; fxm := (-6.0)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.1800000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -3.2999999999999994; fxm := (-6.0)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.27000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -2.3999999999999995; fxm := (-6.0)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.36000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -1.4999999999999996; fxm := (-6.0)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.45000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := -0.5999999999999995; fxm := (-6.0)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.54000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 0.3000000000000005; fxm := (-6.0)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.63000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 1.2000000000000006; fxm := (-6.0)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.72000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 2.1000000000000005; fxm := (-6.0)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.81000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 3.0000000000000004; fxm := (-6.0)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.90000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 3.9000000000000004; fxm := (-6.0)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.99000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 4.800000000000001; fxm := (-6.0)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.10800000000000001e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -6.0; y := 5.700000000000001; fxm := (-6.0)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.11700000000000001e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-6.0,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -6.0; fxm := (-5.2)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.8e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -5.1; fxm := (-5.2)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.1e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -4.199999999999999; fxm := (-5.2)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.1000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -3.2999999999999994; fxm := (-5.2)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.19000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -2.3999999999999995; fxm := (-5.2)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.28000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -1.4999999999999996; fxm := (-5.2)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.37000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := -0.5999999999999995; fxm := (-5.2)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.46000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 0.3000000000000005; fxm := (-5.2)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.55000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 1.2000000000000006; fxm := (-5.2)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.64000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 2.1000000000000005; fxm := (-5.2)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.73000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 3.0000000000000004; fxm := (-5.2)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.82000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 3.9000000000000004; fxm := (-5.2)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.91000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 4.800000000000001; fxm := (-5.2)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.10000000000000001e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -5.2; y := 5.700000000000001; fxm := (-5.2)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.10900000000000001e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-5.2,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -6.0; fxm := (-4.4)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.16e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -5.1; fxm := (-4.4)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.7e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -4.199999999999999; fxm := (-4.4)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.200000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -3.2999999999999994; fxm := (-4.4)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.11000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -2.3999999999999995; fxm := (-4.4)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.20000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -1.4999999999999996; fxm := (-4.4)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.29000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := -0.5999999999999995; fxm := (-4.4)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.38000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 0.3000000000000005; fxm := (-4.4)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.47000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 1.2000000000000006; fxm := (-4.4)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.56000000000000006e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 2.1000000000000005; fxm := (-4.4)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.65000000000000005e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 3.0000000000000004; fxm := (-4.4)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.74000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 3.9000000000000004; fxm := (-4.4)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.83000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 4.800000000000001; fxm := (-4.4)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.9200000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -4.4; y := 5.700000000000001; fxm := (-4.4)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.10100000000000001e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-4.4,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -6.0; fxm := (-3.6000000000000005)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.23999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -5.1; fxm := (-3.6000000000000005)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.14999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -4.199999999999999; fxm := (-3.6000000000000005)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.5999999999999985e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -3.2999999999999994; fxm := (-3.6000000000000005)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.3000000000000011e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -2.3999999999999995; fxm := (-3.6000000000000005)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.1200000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -1.4999999999999996; fxm := (-3.6000000000000005)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.21000000000000009e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -0.5999999999999995; fxm := (-3.6000000000000005)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.3000000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 0.3000000000000005; fxm := (-3.6000000000000005)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.3900000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 1.2000000000000006; fxm := (-3.6000000000000005)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.48000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 2.1000000000000005; fxm := (-3.6000000000000005)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.5700000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.0000000000000004; fxm := (-3.6000000000000005)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.66000000000000009e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.9000000000000004; fxm := (-3.6000000000000005)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.75000000000000009e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 4.800000000000001; fxm := (-3.6000000000000005)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.84000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 5.700000000000001; fxm := (-3.6000000000000005)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.93000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-3.6000000000000005,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -6.0; fxm := (-2.8000000000000007)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.31999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -5.1; fxm := (-2.8000000000000007)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.22999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -4.199999999999999; fxm := (-2.8000000000000007)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.13999999999999983e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -3.2999999999999994; fxm := (-2.8000000000000007)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.4999999999999987e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -2.3999999999999995; fxm := (-2.8000000000000007)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.4000000000000012e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -1.4999999999999996; fxm := (-2.8000000000000007)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.13000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -0.5999999999999995; fxm := (-2.8000000000000007)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.22000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 0.3000000000000005; fxm := (-2.8000000000000007)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.31000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 1.2000000000000006; fxm := (-2.8000000000000007)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.40000000000000013e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 2.1000000000000005; fxm := (-2.8000000000000007)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.49000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.0000000000000004; fxm := (-2.8000000000000007)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.58000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.9000000000000004; fxm := (-2.8000000000000007)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.67000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 4.800000000000001; fxm := (-2.8000000000000007)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.76000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 5.700000000000001; fxm := (-2.8000000000000007)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.85000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.8000000000000007,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -6.0; fxm := (-2.000000000000001)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.3999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -5.1; fxm := (-2.000000000000001)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.3099999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -4.199999999999999; fxm := (-2.000000000000001)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.2199999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -3.2999999999999994; fxm := (-2.000000000000001)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.12999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -2.3999999999999995; fxm := (-2.000000000000001)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.3999999999999985e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -1.4999999999999996; fxm := (-2.000000000000001)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.5000000000000014e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -0.5999999999999995; fxm := (-2.000000000000001)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.14000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 0.3000000000000005; fxm := (-2.000000000000001)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.23000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 1.2000000000000006; fxm := (-2.000000000000001)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.32000000000000016e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 2.1000000000000005; fxm := (-2.000000000000001)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.41000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.0000000000000004; fxm := (-2.000000000000001)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.50000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.9000000000000004; fxm := (-2.000000000000001)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.59000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 4.800000000000001; fxm := (-2.000000000000001)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.6800000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 5.700000000000001; fxm := (-2.000000000000001)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.7700000000000002e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-2.000000000000001,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -6.0; fxm := (-1.2000000000000008)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.47999999999999992e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -5.1; fxm := (-1.2000000000000008)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.38999999999999992e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -4.199999999999999; fxm := (-1.2000000000000008)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.29999999999999982e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -3.2999999999999994; fxm := (-1.2000000000000008)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.20999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -2.3999999999999995; fxm := (-1.2000000000000008)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.11999999999999987e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -1.4999999999999996; fxm := (-1.2000000000000008)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.2999999999999988e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -0.5999999999999995; fxm := (-1.2000000000000008)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.6000000000000013e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 0.3000000000000005; fxm := (-1.2000000000000008)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.15000000000000013e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 1.2000000000000006; fxm := (-1.2000000000000008)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.24000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 2.1000000000000005; fxm := (-1.2000000000000008)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.33000000000000013e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.0000000000000004; fxm := (-1.2000000000000008)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.42000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.9000000000000004; fxm := (-1.2000000000000008)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.51000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 4.800000000000001; fxm := (-1.2000000000000008)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.60000000000000018e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 5.700000000000001; fxm := (-1.2000000000000008)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.69000000000000018e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-1.2000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -6.0; fxm := (-0.4000000000000008)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.55999999999999992e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -5.1; fxm := (-0.4000000000000008)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.46999999999999992e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -4.199999999999999; fxm := (-0.4000000000000008)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.37999999999999982e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -3.2999999999999994; fxm := (-0.4000000000000008)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.28999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -2.3999999999999995; fxm := (-0.4000000000000008)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.19999999999999987e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -1.4999999999999996; fxm := (-0.4000000000000008)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.10999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -0.5999999999999995; fxm := (-0.4000000000000008)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.1999999999999987e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 0.3000000000000005; fxm := (-0.4000000000000008)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.7000000000000013e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 1.2000000000000006; fxm := (-0.4000000000000008)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.16000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 2.1000000000000005; fxm := (-0.4000000000000008)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.25000000000000013e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.0000000000000004; fxm := (-0.4000000000000008)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.34000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.9000000000000004; fxm := (-0.4000000000000008)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.43000000000000012e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 4.800000000000001; fxm := (-0.4000000000000008)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.52000000000000018e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 5.700000000000001; fxm := (-0.4000000000000008)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.61000000000000018e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,-0.4000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -6.0; fxm := (0.39999999999999925)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.639999999999999925e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -5.1; fxm := (0.39999999999999925)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.549999999999999925e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -4.199999999999999; fxm := (0.39999999999999925)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.459999999999999825e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -3.2999999999999994; fxm := (0.39999999999999925)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.369999999999999865e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -2.3999999999999995; fxm := (0.39999999999999925)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.279999999999999875e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -1.4999999999999996; fxm := (0.39999999999999925)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.189999999999999885e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -0.5999999999999995; fxm := (0.39999999999999925)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.99999999999999875e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 0.3000000000000005; fxm := (0.39999999999999925)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.9999999999999875e-1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 1.2000000000000006; fxm := (0.39999999999999925)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.80000000000000135e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 2.1000000000000005; fxm := (0.39999999999999925)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.170000000000000125e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.0000000000000004; fxm := (0.39999999999999925)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.260000000000000115e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.9000000000000004; fxm := (0.39999999999999925)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.350000000000000115e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 4.800000000000001; fxm := (0.39999999999999925)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.440000000000000175e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 5.700000000000001; fxm := (0.39999999999999925)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.530000000000000175e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,0.39999999999999925,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -6.0; fxm := (1.1999999999999993)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.71999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -5.1; fxm := (1.1999999999999993)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.62999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -4.199999999999999; fxm := (1.1999999999999993)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.53999999999999983e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -3.2999999999999994; fxm := (1.1999999999999993)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.44999999999999987e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -2.3999999999999995; fxm := (1.1999999999999993)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.35999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -1.4999999999999996; fxm := (1.1999999999999993)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.26999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -0.5999999999999995; fxm := (1.1999999999999993)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.17999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 0.3000000000000005; fxm := (1.1999999999999993)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.8999999999999988e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 1.2000000000000006; fxm := (1.1999999999999993)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.13e-14; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 2.1000000000000005; fxm := (1.1999999999999993)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.9000000000000012e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.0000000000000004; fxm := (1.1999999999999993)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.18000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.9000000000000004; fxm := (1.1999999999999993)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.27000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 4.800000000000001; fxm := (1.1999999999999993)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.36000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 5.700000000000001; fxm := (1.1999999999999993)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.45000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.1999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -6.0; fxm := (1.9999999999999993)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.79999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -5.1; fxm := (1.9999999999999993)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.70999999999999993e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -4.199999999999999; fxm := (1.9999999999999993)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.61999999999999983e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -3.2999999999999994; fxm := (1.9999999999999993)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.52999999999999987e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -2.3999999999999995; fxm := (1.9999999999999993)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.43999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -1.4999999999999996; fxm := (1.9999999999999993)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.34999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -0.5999999999999995; fxm := (1.9999999999999993)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.25999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 0.3000000000000005; fxm := (1.9999999999999993)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.16999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 1.2000000000000006; fxm := (1.9999999999999993)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.7999999999999987e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 2.1000000000000005; fxm := (1.9999999999999993)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.1000000000000012e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.0000000000000004; fxm := (1.9999999999999993)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.10000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.9000000000000004; fxm := (1.9999999999999993)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.19000000000000011e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 4.800000000000001; fxm := (1.9999999999999993)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.28000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 5.700000000000001; fxm := (1.9999999999999993)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.37000000000000017e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,1.9999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -6.0; fxm := (2.7999999999999994)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.87999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -5.1; fxm := (2.7999999999999994)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.78999999999999994e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -4.199999999999999; fxm := (2.7999999999999994)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.69999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -3.2999999999999994; fxm := (2.7999999999999994)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.60999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -2.3999999999999995; fxm := (2.7999999999999994)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.51999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -1.4999999999999996; fxm := (2.7999999999999994)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.4299999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -0.5999999999999995; fxm := (2.7999999999999994)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.33999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 0.3000000000000005; fxm := (2.7999999999999994)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.24999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 1.2000000000000006; fxm := (2.7999999999999994)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.15999999999999988e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 2.1000000000000005; fxm := (2.7999999999999994)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.6999999999999989e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.0000000000000004; fxm := (2.7999999999999994)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.200000000000001e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.9000000000000004; fxm := (2.7999999999999994)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.1100000000000001e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 4.800000000000001; fxm := (2.7999999999999994)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.20000000000000016e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 5.700000000000001; fxm := (2.7999999999999994)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.29000000000000016e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,2.7999999999999994,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -6.0; fxm := (3.5999999999999996)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.95999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -5.1; fxm := (3.5999999999999996)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.86999999999999996e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -4.199999999999999; fxm := (3.5999999999999996)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.77999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -3.2999999999999994; fxm := (3.5999999999999996)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.6899999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -2.3999999999999995; fxm := (3.5999999999999996)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.59999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -1.4999999999999996; fxm := (3.5999999999999996)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.50999999999999992e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -0.5999999999999995; fxm := (3.5999999999999996)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.41999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 0.3000000000000005; fxm := (3.5999999999999996)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.32999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 1.2000000000000006; fxm := (3.5999999999999996)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.2399999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 2.1000000000000005; fxm := (3.5999999999999996)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.14999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.0000000000000004; fxm := (3.5999999999999996)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.5999999999999992e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.9000000000000004; fxm := (3.5999999999999996)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.3000000000000008e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 4.800000000000001; fxm := (3.5999999999999996)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.12000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 5.700000000000001; fxm := (3.5999999999999996)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.21000000000000014e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,3.5999999999999996,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -6.0; fxm := (4.3999999999999995)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.103999999999999995e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -5.1; fxm := (4.3999999999999995)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.94999999999999995e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -4.199999999999999; fxm := (4.3999999999999995)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.85999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -3.2999999999999994; fxm := (4.3999999999999995)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.76999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -2.3999999999999995; fxm := (4.3999999999999995)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.6799999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -1.4999999999999996; fxm := (4.3999999999999995)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.58999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -0.5999999999999995; fxm := (4.3999999999999995)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.4999999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 0.3000000000000005; fxm := (4.3999999999999995)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.4099999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 1.2000000000000006; fxm := (4.3999999999999995)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.31999999999999989e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 2.1000000000000005; fxm := (4.3999999999999995)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.2299999999999999e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.0000000000000004; fxm := (4.3999999999999995)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.13999999999999991e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.9000000000000004; fxm := (4.3999999999999995)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.4999999999999991e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 4.800000000000001; fxm := (4.3999999999999995)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.4000000000000015e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 5.700000000000001; fxm := (4.3999999999999995)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.13000000000000015e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,4.3999999999999995,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -6.0; fxm := (5.199999999999999)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.11199999999999999e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -5.1; fxm := (5.199999999999999)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.10299999999999999e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -4.199999999999999; fxm := (5.199999999999999)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.9399999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -3.2999999999999994; fxm := (5.199999999999999)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.84999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -2.3999999999999995; fxm := (5.199999999999999)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.75999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -1.4999999999999996; fxm := (5.199999999999999)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.66999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -0.5999999999999995; fxm := (5.199999999999999)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.57999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 0.3000000000000005; fxm := (5.199999999999999)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.48999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 1.2000000000000006; fxm := (5.199999999999999)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.39999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 2.1000000000000005; fxm := (5.199999999999999)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.30999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.0000000000000004; fxm := (5.199999999999999)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.21999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.9000000000000004; fxm := (5.199999999999999)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.12999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 4.800000000000001; fxm := (5.199999999999999)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.399999999999998e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 5.700000000000001; fxm := (5.199999999999999)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.500000000000002e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.199999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -6.0; fxm := (5.999999999999999)-(-6.0); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.11999999999999999e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -5.1; fxm := (5.999999999999999)-(-5.1); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.11099999999999999e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -4.199999999999999; fxm := (5.999999999999999)-(-4.199999999999999); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.10199999999999998e2; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -3.2999999999999994; fxm := (5.999999999999999)-(-3.2999999999999994); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.92999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -2.3999999999999995; fxm := (5.999999999999999)-(-2.3999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.83999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -1.4999999999999996; fxm := (5.999999999999999)-(-1.4999999999999996); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.74999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -0.5999999999999995; fxm := (5.999999999999999)-(-0.5999999999999995); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.65999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 0.3000000000000005; fxm := (5.999999999999999)-(0.3000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.56999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 1.2000000000000006; fxm := (5.999999999999999)-(1.2000000000000006); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.47999999999999984e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 2.1000000000000005; fxm := (5.999999999999999)-(2.1000000000000005); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.38999999999999985e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.0000000000000004; fxm := (5.999999999999999)-(3.0000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.29999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.9000000000000004; fxm := (5.999999999999999)-(3.9000000000000004); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.20999999999999986e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 4.800000000000001; fxm := (5.999999999999999)-(4.800000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.1199999999999998e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = subtraction \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 5.700000000000001; fxm := (5.999999999999999)-(5.700000000000001); fffx := x -> x -y; fffy := y -> x -y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.299999999999998e0; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(subtraction,5.999999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(out_fd,"Operator = multiplication\n"): fprintf(except_fd,"Operator = multiplication\n"): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -6.0; fxm := (-6.0)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.36e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -5.1; fxm := (-6.0)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.306e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -4.199999999999999; fxm := (-6.0)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.25199999999999994e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -3.2999999999999994; fxm := (-6.0)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.197999999999999964e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -2.3999999999999995; fxm := (-6.0)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.14399999999999997e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -1.4999999999999996; fxm := (-6.0)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.89999999999999976e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := -0.5999999999999995; fxm := (-6.0)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.3599999999999997e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 0.3000000000000005; fxm := (-6.0)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.1800000000000003e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 1.2000000000000006; fxm := (-6.0)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.72000000000000036e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 2.1000000000000005; fxm := (-6.0)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.12600000000000003e2; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 3.0000000000000004; fxm := (-6.0)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.180000000000000024e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 3.9000000000000004; fxm := (-6.0)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.234000000000000024e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 4.800000000000001; fxm := (-6.0)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.28800000000000006e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -6.0; y := 5.700000000000001; fxm := (-6.0)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.34200000000000006e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-6.0,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -6.0; fxm := (-5.2)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.312e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -5.1; fxm := (-5.2)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.2652e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -4.199999999999999; fxm := (-5.2)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.218399999999999948e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -3.2999999999999994; fxm := (-5.2)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.1715999999999999688e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -2.3999999999999995; fxm := (-5.2)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.124799999999999974e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -1.4999999999999996; fxm := (-5.2)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.779999999999999792e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := -0.5999999999999995; fxm := (-5.2)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.31199999999999974e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 0.3000000000000005; fxm := (-5.2)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.15600000000000026e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 1.2000000000000006; fxm := (-5.2)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.624000000000000312e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 2.1000000000000005; fxm := (-5.2)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.109200000000000026e2; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 3.0000000000000004; fxm := (-5.2)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.1560000000000000208e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 3.9000000000000004; fxm := (-5.2)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.2028000000000000208e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 4.800000000000001; fxm := (-5.2)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.249600000000000052e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -5.2; y := 5.700000000000001; fxm := (-5.2)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.296400000000000052e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-5.2,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -6.0; fxm := (-4.4)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.264e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -5.1; fxm := (-4.4)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.2244e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -4.199999999999999; fxm := (-4.4)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.184799999999999956e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -3.2999999999999994; fxm := (-4.4)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.1451999999999999736e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -2.3999999999999995; fxm := (-4.4)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.105599999999999978e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -1.4999999999999996; fxm := (-4.4)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.659999999999999824e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := -0.5999999999999995; fxm := (-4.4)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.26399999999999978e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 0.3000000000000005; fxm := (-4.4)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.13200000000000022e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 1.2000000000000006; fxm := (-4.4)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.528000000000000264e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 2.1000000000000005; fxm := (-4.4)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.92400000000000022e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 3.0000000000000004; fxm := (-4.4)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.1320000000000000176e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 3.9000000000000004; fxm := (-4.4)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.1716000000000000176e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 4.800000000000001; fxm := (-4.4)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.211200000000000044e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -4.4; y := 5.700000000000001; fxm := (-4.4)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.250800000000000044e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-4.4,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -6.0; fxm := (-3.6000000000000005)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.21600000000000003e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -5.1; fxm := (-3.6000000000000005)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.1836000000000000255e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -4.199999999999999; fxm := (-3.6000000000000005)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.151199999999999984999999999999995e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -3.2999999999999994; fxm := (-3.6000000000000005)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.118799999999999994899999999999997e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -2.3999999999999995; fxm := (-3.6000000000000005)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.863999999999999939999999999999975e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -1.4999999999999996; fxm := (-3.6000000000000005)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.53999999999999993099999999999998e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -0.5999999999999995; fxm := (-3.6000000000000005)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.215999999999999849999999999999975e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 0.3000000000000005; fxm := (-3.6000000000000005)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.108000000000000195000000000000025e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 1.2000000000000006; fxm := (-3.6000000000000005)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.43200000000000027600000000000003e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 2.1000000000000005; fxm := (-3.6000000000000005)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.756000000000000285000000000000025e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.0000000000000004; fxm := (-3.6000000000000005)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.108000000000000029400000000000002e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.9000000000000004; fxm := (-3.6000000000000005)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.140400000000000033900000000000002e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 4.800000000000001; fxm := (-3.6000000000000005)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.172800000000000060000000000000005e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 5.700000000000001; fxm := (-3.6000000000000005)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.205200000000000064500000000000005e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-3.6000000000000005,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -6.0; fxm := (-2.8000000000000007)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.168000000000000042e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -5.1; fxm := (-2.8000000000000007)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.1428000000000000357e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -4.199999999999999; fxm := (-2.8000000000000007)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.117600000000000001399999999999993e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -3.2999999999999994; fxm := (-2.8000000000000007)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.924000000000000062999999999999958e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -2.3999999999999995; fxm := (-2.8000000000000007)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.672000000000000027999999999999965e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -1.4999999999999996; fxm := (-2.8000000000000007)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.419999999999999992999999999999972e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -0.5999999999999995; fxm := (-2.8000000000000007)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.167999999999999901999999999999965e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 0.3000000000000005; fxm := (-2.8000000000000007)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.84000000000000161000000000000035e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 1.2000000000000006; fxm := (-2.8000000000000007)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.336000000000000252000000000000042e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 2.1000000000000005; fxm := (-2.8000000000000007)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.588000000000000287000000000000035e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.0000000000000004; fxm := (-2.8000000000000007)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.840000000000000322000000000000028e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.9000000000000004; fxm := (-2.8000000000000007)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.1092000000000000385000000000000028e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 4.800000000000001; fxm := (-2.8000000000000007)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.134400000000000061600000000000007e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 5.700000000000001; fxm := (-2.8000000000000007)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.159600000000000067900000000000007e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.8000000000000007,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -6.0; fxm := (-2.000000000000001)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.12000000000000006e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -5.1; fxm := (-2.000000000000001)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.102000000000000051e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -4.199999999999999; fxm := (-2.000000000000001)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.8400000000000002199999999999999e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -3.2999999999999994; fxm := (-2.000000000000001)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.66000000000000020999999999999994e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -2.3999999999999995; fxm := (-2.000000000000001)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.48000000000000013999999999999995e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -1.4999999999999996; fxm := (-2.000000000000001)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.30000000000000006999999999999996e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -0.5999999999999995; fxm := (-2.000000000000001)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.11999999999999995999999999999995e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 0.3000000000000005; fxm := (-2.000000000000001)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.6000000000000013000000000000005e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 1.2000000000000006; fxm := (-2.000000000000001)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.24000000000000024000000000000006e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 2.1000000000000005; fxm := (-2.000000000000001)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.42000000000000031000000000000005e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.0000000000000004; fxm := (-2.000000000000001)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.60000000000000038000000000000004e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.9000000000000004; fxm := (-2.000000000000001)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.78000000000000047000000000000004e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 4.800000000000001; fxm := (-2.000000000000001)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.9600000000000006800000000000001e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 5.700000000000001; fxm := (-2.000000000000001)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.11400000000000007700000000000001e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-2.000000000000001,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -6.0; fxm := (-1.2000000000000008)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.72000000000000048e1; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -5.1; fxm := (-1.2000000000000008)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.612000000000000408e1; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -4.199999999999999; fxm := (-1.2000000000000008)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.50400000000000021599999999999992e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -3.2999999999999994; fxm := (-1.2000000000000008)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.396000000000000191999999999999952e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -2.3999999999999995; fxm := (-1.2000000000000008)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.28800000000000013199999999999996e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -1.4999999999999996; fxm := (-1.2000000000000008)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.180000000000000071999999999999968e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -0.5999999999999995; fxm := (-1.2000000000000008)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.7199999999999998799999999999996e0; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 0.3000000000000005; fxm := (-1.2000000000000008)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.3600000000000008400000000000004e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 1.2000000000000006; fxm := (-1.2000000000000008)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.144000000000000168000000000000048e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 2.1000000000000005; fxm := (-1.2000000000000008)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.25200000000000022800000000000004e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.0000000000000004; fxm := (-1.2000000000000008)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.360000000000000288000000000000032e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.9000000000000004; fxm := (-1.2000000000000008)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.468000000000000360000000000000032e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 4.800000000000001; fxm := (-1.2000000000000008)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.57600000000000050400000000000008e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 5.700000000000001; fxm := (-1.2000000000000008)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.68400000000000057600000000000008e1; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-1.2000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -6.0; fxm := (-0.4000000000000008)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.24000000000000048e1; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -5.1; fxm := (-0.4000000000000008)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.204000000000000408e1; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -4.199999999999999; fxm := (-0.4000000000000008)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.16800000000000029599999999999992e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -3.2999999999999994; fxm := (-0.4000000000000008)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.132000000000000239999999999999952e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -2.3999999999999995; fxm := (-0.4000000000000008)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.9600000000000017199999999999996e0; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -1.4999999999999996; fxm := (-0.4000000000000008)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.60000000000000103999999999999968e0; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -0.5999999999999995; fxm := (-0.4000000000000008)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.2400000000000002799999999999996e0; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 0.3000000000000005; fxm := (-0.4000000000000008)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.1200000000000004400000000000004e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 1.2000000000000006; fxm := (-0.4000000000000008)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.48000000000000120000000000000048e0; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 2.1000000000000005; fxm := (-0.4000000000000008)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.8400000000000018800000000000004e0; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.0000000000000004; fxm := (-0.4000000000000008)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.120000000000000256000000000000032e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.9000000000000004; fxm := (-0.4000000000000008)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.156000000000000328000000000000032e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 4.800000000000001; fxm := (-0.4000000000000008)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.19200000000000042400000000000008e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 5.700000000000001; fxm := (-0.4000000000000008)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.22800000000000049600000000000008e1; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,-0.4000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -6.0; fxm := (0.39999999999999925)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.23999999999999955e1; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -5.1; fxm := (0.39999999999999925)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.2039999999999996175e1; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -4.199999999999999; fxm := (0.39999999999999925)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.167999999999999645000000000000075e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -3.2999999999999994; fxm := (0.39999999999999925)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.131999999999999728500000000000045e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -2.3999999999999995; fxm := (0.39999999999999925)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.959999999999998000000000000000375e0; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -1.4999999999999996; fxm := (0.39999999999999925)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.5999999999999987150000000000003e0; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -0.5999999999999995; fxm := (0.39999999999999925)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.239999999999999350000000000000375e0; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 0.3000000000000005; fxm := (0.39999999999999925)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.119999999999999974999999999999625e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 1.2000000000000006; fxm := (0.39999999999999925)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.47999999999999933999999999999955e0; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 2.1000000000000005; fxm := (0.39999999999999925)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.839999999999998624999999999999625e0; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.0000000000000004; fxm := (0.39999999999999925)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.11999999999999979099999999999997e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.9000000000000004; fxm := (0.39999999999999925)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.15599999999999972349999999999997e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 4.800000000000001; fxm := (0.39999999999999925)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.191999999999999679999999999999925e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 5.700000000000001; fxm := (0.39999999999999925)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.227999999999999612499999999999925e1; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,0.39999999999999925,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -6.0; fxm := (1.1999999999999993)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.71999999999999958e1; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -5.1; fxm := (1.1999999999999993)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.611999999999999643e1; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -4.199999999999999; fxm := (1.1999999999999993)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.50399999999999958600000000000007e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -3.2999999999999994; fxm := (1.1999999999999993)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.395999999999999697000000000000042e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -2.3999999999999995; fxm := (1.1999999999999993)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.287999999999999772000000000000035e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -1.4999999999999996; fxm := (1.1999999999999993)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.179999999999999847000000000000028e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -0.5999999999999995; fxm := (1.1999999999999993)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.71999999999999898000000000000035e0; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 0.3000000000000005; fxm := (1.1999999999999993)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.36000000000000038999999999999965e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 1.2000000000000006; fxm := (1.1999999999999993)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.143999999999999987999999999999958e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 2.1000000000000005; fxm := (1.1999999999999993)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.251999999999999912999999999999965e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.0000000000000004; fxm := (1.1999999999999993)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.359999999999999837999999999999972e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.9000000000000004; fxm := (1.1999999999999993)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.467999999999999774999999999999972e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 4.800000000000001; fxm := (1.1999999999999993)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.57599999999999978399999999999993e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 5.700000000000001; fxm := (1.1999999999999993)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.68399999999999972099999999999993e1; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.1999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -6.0; fxm := (1.9999999999999993)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.119999999999999958e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -5.1; fxm := (1.9999999999999993)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.1019999999999999643e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -4.199999999999999; fxm := (1.9999999999999993)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.83999999999999950600000000000007e1; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -3.2999999999999994; fxm := (1.9999999999999993)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.659999999999999649000000000000042e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -2.3999999999999995; fxm := (1.9999999999999993)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.479999999999999732000000000000035e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -1.4999999999999996; fxm := (1.9999999999999993)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.299999999999999815000000000000028e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -0.5999999999999995; fxm := (1.9999999999999993)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.119999999999999858000000000000035e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 0.3000000000000005; fxm := (1.9999999999999993)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.60000000000000078999999999999965e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 1.2000000000000006; fxm := (1.9999999999999993)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.240000000000000035999999999999958e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 2.1000000000000005; fxm := (1.9999999999999993)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.419999999999999952999999999999965e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.0000000000000004; fxm := (1.9999999999999993)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.599999999999999869999999999999972e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.9000000000000004; fxm := (1.9999999999999993)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.779999999999999806999999999999972e1; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 4.800000000000001; fxm := (1.9999999999999993)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.95999999999999986399999999999993e1; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 5.700000000000001; fxm := (1.9999999999999993)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.113999999999999980099999999999993e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,1.9999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -6.0; fxm := (2.7999999999999994)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.167999999999999964e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -5.1; fxm := (2.7999999999999994)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.1427999999999999694e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -4.199999999999999; fxm := (2.7999999999999994)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.117599999999999946800000000000006e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -3.2999999999999994; fxm := (2.7999999999999994)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.923999999999999634000000000000036e1; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -2.3999999999999995; fxm := (2.7999999999999994)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.67199999999999971600000000000003e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -1.4999999999999996; fxm := (2.7999999999999994)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.419999999999999798000000000000024e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -0.5999999999999995; fxm := (2.7999999999999994)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.16799999999999982400000000000003e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 0.3000000000000005; fxm := (2.7999999999999994)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.8400000000000012199999999999997e0; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 1.2000000000000006; fxm := (2.7999999999999994)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.336000000000000095999999999999964e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 2.1000000000000005; fxm := (2.7999999999999994)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.58800000000000001399999999999997e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.0000000000000004; fxm := (2.7999999999999994)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.839999999999999931999999999999976e1; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.9000000000000004; fxm := (2.7999999999999994)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.1091999999999999877999999999999976e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 4.800000000000001; fxm := (2.7999999999999994)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.134399999999999999199999999999994e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 5.700000000000001; fxm := (2.7999999999999994)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.159599999999999993799999999999994e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,2.7999999999999994,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -6.0; fxm := (3.5999999999999996)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.215999999999999976e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -5.1; fxm := (3.5999999999999996)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.1835999999999999796e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -4.199999999999999; fxm := (3.5999999999999996)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.151199999999999947200000000000004e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -3.2999999999999994; fxm := (3.5999999999999996)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.1187999999999999652000000000000024e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -2.3999999999999995; fxm := (3.5999999999999996)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.86399999999999972400000000000002e1; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -1.4999999999999996; fxm := (3.5999999999999996)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.539999999999999796000000000000016e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -0.5999999999999995; fxm := (3.5999999999999996)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.21599999999999979600000000000002e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 0.3000000000000005; fxm := (3.5999999999999996)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.10800000000000016799999999999998e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 1.2000000000000006; fxm := (3.5999999999999996)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.432000000000000167999999999999976e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 2.1000000000000005; fxm := (3.5999999999999996)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.75600000000000009599999999999998e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.0000000000000004; fxm := (3.5999999999999996)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.1080000000000000023999999999999984e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.9000000000000004; fxm := (3.5999999999999996)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.1403999999999999987999999999999984e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 4.800000000000001; fxm := (3.5999999999999996)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.172800000000000016799999999999996e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 5.700000000000001; fxm := (3.5999999999999996)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.205200000000000013199999999999996e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,3.5999999999999996,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -6.0; fxm := (4.3999999999999995)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.26399999999999997e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -5.1; fxm := (4.3999999999999995)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.2243999999999999745e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -4.199999999999999; fxm := (4.3999999999999995)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.184799999999999935000000000000005e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -3.2999999999999994; fxm := (4.3999999999999995)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.145199999999999957100000000000003e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -2.3999999999999995; fxm := (4.3999999999999995)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.1055999999999999660000000000000025e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -1.4999999999999996; fxm := (4.3999999999999995)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.65999999999999974900000000000002e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -0.5999999999999995; fxm := (4.3999999999999995)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.263999999999999750000000000000025e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 0.3000000000000005; fxm := (4.3999999999999995)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.132000000000000204999999999999975e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 1.2000000000000006; fxm := (4.3999999999999995)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.52800000000000020399999999999997e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 2.1000000000000005; fxm := (4.3999999999999995)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.924000000000000114999999999999975e1; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.0000000000000004; fxm := (4.3999999999999995)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.132000000000000002599999999999998e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.9000000000000004; fxm := (4.3999999999999995)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.171599999999999998099999999999998e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 4.800000000000001; fxm := (4.3999999999999995)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.211200000000000019999999999999995e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 5.700000000000001; fxm := (4.3999999999999995)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.250800000000000015499999999999995e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,4.3999999999999995,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -6.0; fxm := (5.199999999999999)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.31199999999999994e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -5.1; fxm := (5.199999999999999)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.265199999999999949e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -4.199999999999999; fxm := (5.199999999999999)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.21839999999999990600000000000001e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -3.2999999999999994; fxm := (5.199999999999999)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.171599999999999935800000000000006e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -2.3999999999999995; fxm := (5.199999999999999)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.124799999999999950000000000000005e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -1.4999999999999996; fxm := (5.199999999999999)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.77999999999999964200000000000004e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -0.5999999999999995; fxm := (5.199999999999999)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.31199999999999968000000000000005e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 0.3000000000000005; fxm := (5.199999999999999)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.15600000000000022999999999999995e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 1.2000000000000006; fxm := (5.199999999999999)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.62400000000000019199999999999994e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 2.1000000000000005; fxm := (5.199999999999999)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.109200000000000004999999999999995e2; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.0000000000000004; fxm := (5.199999999999999)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.155999999999999990799999999999996e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.9000000000000004; fxm := (5.199999999999999)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.202799999999999981799999999999996e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 4.800000000000001; fxm := (5.199999999999999)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.24960000000000000399999999999999e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 5.700000000000001; fxm := (5.199999999999999)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.29639999999999999499999999999999e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.199999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -6.0; fxm := (5.999999999999999)*(-6.0); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.35999999999999994e2; fxrerr := 0.6e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -5.1; fxm := (5.999999999999999)*(-5.1); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.305999999999999949e2; fxrerr := 0.51e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -4.199999999999999; fxm := (5.999999999999999)*(-4.199999999999999); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.25199999999999989800000000000001e2; fxrerr := 0.42e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -3.2999999999999994; fxm := (5.999999999999999)*(-3.2999999999999994); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.197999999999999931000000000000006e2; fxrerr := 0.33e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -2.3999999999999995; fxm := (5.999999999999999)*(-2.3999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.143999999999999946000000000000005e2; fxrerr := 0.24e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -1.4999999999999996; fxm := (5.999999999999999)*(-1.4999999999999996); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.89999999999999961000000000000004e1; fxrerr := 0.15e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -0.5999999999999995; fxm := (5.999999999999999)*(-0.5999999999999995); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.35999999999999964000000000000005e1; fxrerr := 0.6e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 0.3000000000000005; fxm := (5.999999999999999)*(0.3000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.18000000000000026999999999999995e1; fxrerr := 0.3e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 1.2000000000000006; fxm := (5.999999999999999)*(1.2000000000000006); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.72000000000000023999999999999994e1; fxrerr := 0.12e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 2.1000000000000005; fxm := (5.999999999999999)*(2.1000000000000005); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.126000000000000008999999999999995e2; fxrerr := 0.21e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.0000000000000004; fxm := (5.999999999999999)*(3.0000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.179999999999999993999999999999996e2; fxrerr := 0.3e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.9000000000000004; fxm := (5.999999999999999)*(3.9000000000000004); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.233999999999999984999999999999996e2; fxrerr := 0.39e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 4.800000000000001; fxm := (5.999999999999999)*(4.800000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.28800000000000001199999999999999e2; fxrerr := 0.48e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = multiplication \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 5.700000000000001; fxm := (5.999999999999999)*(5.700000000000001); fffx := x -> x *y; fffy := y -> x *y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.34200000000000000299999999999999e2; fxrerr := 0.57e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(multiplication,5.999999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(out_fd,"Operator = division\n"): fprintf(except_fd,"Operator = division\n"): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -6.0; fxm := (-6.0)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.1e1; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -5.1; fxm := (-6.0)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.117647058823529411764705882352941176e1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -4.199999999999999; fxm := (-6.0)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.142857142857142891156462585034021703e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -3.2999999999999994; fxm := (-6.0)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.181818181818181851239669421487609316e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -2.3999999999999995; fxm := (-6.0)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.250000000000000052083333333333344184e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -1.4999999999999996; fxm := (-6.0)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.400000000000000106666666666666695111e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := -0.5999999999999995; fxm := (-6.0)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.100000000000000083333333333333402777e2; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 0.3000000000000005; fxm := (-6.0)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.19999999999999966666666666666722222e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 1.2000000000000006; fxm := (-6.0)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.49999999999999975000000000000012499e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 2.1000000000000005; fxm := (-6.0)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.28571428571428564625850340136056041e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 3.0000000000000004; fxm := (-6.0)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.19999999999999997333333333333333688e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 3.9000000000000004; fxm := (-6.0)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.15384615384615383037475345167653021e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 4.800000000000001; fxm := (-6.0)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.12499999999999997395833333333333875e1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -6.0; y := 5.700000000000001; fxm := (-6.0)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-6.0)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.1052631578947368236380424746075748e1; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-6.0,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -6.0\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -6.0; fxm := (-5.2)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.866666666666666666666666666666666666e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -5.1; fxm := (-5.2)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.101960784313725490196078431372549019e1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -4.199999999999999; fxm := (-5.2)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.123809523809523839002267573696152143e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -3.2999999999999994; fxm := (-5.2)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.15757575757575760440771349862259474e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -2.3999999999999995; fxm := (-5.2)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.216666666666666711805555555555564959e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -1.4999999999999996; fxm := (-5.2)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.346666666666666759111111111111135762e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := -0.5999999999999995; fxm := (-5.2)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.86666666666666738888888888888949074e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 0.3000000000000005; fxm := (-5.2)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.17333333333333304444444444444492592e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 1.2000000000000006; fxm := (-5.2)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.43333333333333311666666666666677499e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 2.1000000000000005; fxm := (-5.2)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.24761904761904756009070294784581902e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 3.0000000000000004; fxm := (-5.2)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.1733333333333333102222222222222253e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 3.9000000000000004; fxm := (-5.2)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.13333333333333331965811965811965952e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 4.800000000000001; fxm := (-5.2)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.10833333333333331076388888888889359e1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -5.2; y := 5.700000000000001; fxm := (-5.2)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-5.2)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.91228070175438580486303477993231493e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-5.2,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -5.2\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -6.0; fxm := (-4.4)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.733333333333333333333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -5.1; fxm := (-4.4)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.862745098039215686274509803921568627e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -4.199999999999999; fxm := (-4.4)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.104761904761904786848072562358282582e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -3.2999999999999994; fxm := (-4.4)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.133333333333333357575757575757580165e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -2.3999999999999995; fxm := (-4.4)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.183333333333333371527777777777785734e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -1.4999999999999996; fxm := (-4.4)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.293333333333333411555555555555576414e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := -0.5999999999999995; fxm := (-4.4)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.733333333333333944444444444444953703e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 0.3000000000000005; fxm := (-4.4)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.14666666666666642222222222222262962e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 1.2000000000000006; fxm := (-4.4)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.36666666666666648333333333333342499e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 2.1000000000000005; fxm := (-4.4)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.20952380952380947392290249433107763e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 3.0000000000000004; fxm := (-4.4)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.14666666666666664711111111111111371e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 3.9000000000000004; fxm := (-4.4)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.11282051282051280894148586456278882e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 4.800000000000001; fxm := (-4.4)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.91666666666666647569444444444448423e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -4.4; y := 5.700000000000001; fxm := (-4.4)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-4.4)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.77192982456140337334564481378888186e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-4.4,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -4.4\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -6.0; fxm := (-3.6000000000000005)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.600000000000000083333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -5.1; fxm := (-3.6000000000000005)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.705882352941176568627450980392156862e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -4.199999999999999; fxm := (-3.6000000000000005)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.857142857142857465986394557823206187e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -3.2999999999999994; fxm := (-3.6000000000000005)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.109090909090909125895316804407719859e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -2.3999999999999995; fxm := (-3.6000000000000005)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.150000000000000052083333333333344184e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -1.4999999999999996; fxm := (-3.6000000000000005)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.240000000000000097333333333333359288e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := -0.5999999999999995; fxm := (-3.6000000000000005)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.600000000000000583333333333333819444e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 0.3000000000000005; fxm := (-3.6000000000000005)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.11999999999999981666666666666697222e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 1.2000000000000006; fxm := (-3.6000000000000005)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.29999999999999989166666666666672083e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 2.1000000000000005; fxm := (-3.6000000000000005)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.1714285714285714115646258503401401e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.0000000000000004; fxm := (-3.6000000000000005)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.12000000000000000066666666666666657e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 3.9000000000000004; fxm := (-3.6000000000000005)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.92307692307692311045364891518737328e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 4.800000000000001; fxm := (-3.6000000000000005)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.74999999999999994791666666666667751e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -3.6000000000000005; y := 5.700000000000001; fxm := (-3.6000000000000005)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-3.6000000000000005)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.6315789473684210295475530932594685e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-3.6000000000000005,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -3.6000000000000005\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -6.0; fxm := (-2.8000000000000007)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.466666666666666783333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -5.1; fxm := (-2.8000000000000007)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.549019607843137392156862745098039215e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -4.199999999999999; fxm := (-2.8000000000000007)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.666666666666666992063492063492140967e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -3.2999999999999994; fxm := (-2.8000000000000007)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.848484848484848851239669421487669922e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -2.3999999999999995; fxm := (-2.8000000000000007)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.116666666666666720138888888888900028e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -1.4999999999999996; fxm := (-2.8000000000000007)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.186666666666666763111111111111136829e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := -0.5999999999999995; fxm := (-2.8000000000000007)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.466666666666667172222222222222643518e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 0.3000000000000005; fxm := (-2.8000000000000007)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.93333333333333201111111111111331481e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 1.2000000000000006; fxm := (-2.8000000000000007)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.23333333333333327500000000000002916e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 2.1000000000000005; fxm := (-2.8000000000000007)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.13333333333333333492063492063492025e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.0000000000000004; fxm := (-2.8000000000000007)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.9333333333333334422222222222222077e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 3.9000000000000004; fxm := (-2.8000000000000007)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.71794871794871805456936226166994312e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 4.800000000000001; fxm := (-2.8000000000000007)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.58333333333333335763888888888888382e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.8000000000000007; y := 5.700000000000001; fxm := (-2.8000000000000007)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.8000000000000007)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.49122807017543863311788242536164331e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.8000000000000007,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.8000000000000007\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -6.0; fxm := (-2.000000000000001)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.3333333333333335e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -5.1; fxm := (-2.000000000000001)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.392156862745098235294117647058823529e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -4.199999999999999; fxm := (-2.000000000000001)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.47619047619047654195011337868489094e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -3.2999999999999994; fxm := (-2.000000000000001)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.606060606060606473829201101928449787e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -2.3999999999999995; fxm := (-2.000000000000001)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.833333333333333923611111111111234085e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -1.4999999999999996; fxm := (-2.000000000000001)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.133333333333333435555555555555582814e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := -0.5999999999999995; fxm := (-2.000000000000001)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.333333333333333777777777777778148148e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 0.3000000000000005; fxm := (-2.000000000000001)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.66666666666666588888888888889018518e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 1.2000000000000006; fxm := (-2.000000000000001)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.16666666666666666666666666666666666e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 2.1000000000000005; fxm := (-2.000000000000001)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.95238095238095263038548752834461181e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.0000000000000004; fxm := (-2.000000000000001)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.66666666666666691111111111111107851e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 3.9000000000000004; fxm := (-2.000000000000001)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.51282051282051302432610124917815135e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 4.800000000000001; fxm := (-2.000000000000001)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.41666666666666678819444444444441912e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -2.000000000000001; y := 5.700000000000001; fxm := (-2.000000000000001)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-2.000000000000001)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.35087719298245625423207140658662206e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-2.000000000000001,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -2.000000000000001\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -6.0; fxm := (-1.2000000000000008)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.200000000000000133333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -5.1; fxm := (-1.2000000000000008)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.235294117647058980392156862745098039e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -4.199999999999999; fxm := (-1.2000000000000008)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.285714285714285972789115646258564949e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -3.2999999999999994; fxm := (-1.2000000000000008)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.363636363636363944903581267217686952e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -2.3999999999999995; fxm := (-1.2000000000000008)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.500000000000000437500000000000091145e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -1.4999999999999996; fxm := (-1.2000000000000008)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.800000000000000746666666666666865777e0; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := -0.5999999999999995; fxm := (-1.2000000000000008)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.20000000000000030000000000000025e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 0.3000000000000005; fxm := (-1.2000000000000008)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.39999999999999960000000000000066666e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 1.2000000000000006; fxm := (-1.2000000000000008)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.10000000000000001666666666666665833e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 2.1000000000000005; fxm := (-1.2000000000000008)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.5714285714285716734693877551019825e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.0000000000000004; fxm := (-1.2000000000000008)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.40000000000000021333333333333330488e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 3.9000000000000004; fxm := (-1.2000000000000008)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.3076923076923078658777120315581676e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 4.800000000000001; fxm := (-1.2000000000000008)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.25000000000000011458333333333330946e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -1.2000000000000008; y := 5.700000000000001; fxm := (-1.2000000000000008)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-1.2000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.21052631578947378762696214219758111e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-1.2000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -1.2000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -6.0; fxm := (-0.4000000000000008)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := 0.666666666666668e-1; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -5.1; fxm := (-0.4000000000000008)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := 0.784313725490197647058823529411764705e-1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -4.199999999999999; fxm := (-0.4000000000000008)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := 0.952380952380954512471655328798693445e-1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -3.2999999999999994; fxm := (-0.4000000000000008)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := 0.121212121212121476584022038567541197e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -2.3999999999999995; fxm := (-0.4000000000000008)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := 0.1666666666666670347222222222222989e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -1.4999999999999996; fxm := (-0.4000000000000008)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := 0.266666666666667271111111111111272296e0; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := -0.5999999999999995; fxm := (-0.4000000000000008)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := 0.666666666666668555555555555557129629e0; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 0.3000000000000005; fxm := (-0.4000000000000008)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := -0.1333333333333333777777777777777037e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 1.2000000000000006; fxm := (-0.4000000000000008)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := -0.33333333333333383333333333333308333e0; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 2.1000000000000005; fxm := (-0.4000000000000008)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := -0.19047619047619081179138321995456862e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.0000000000000004; fxm := (-0.4000000000000008)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := -0.13333333333333358222222222222218903e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 3.9000000000000004; fxm := (-0.4000000000000008)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := -0.10256410256410275871137409598946064e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 4.800000000000001; fxm := (-0.4000000000000008)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := -0.83333333333333482638888888888857783e-1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := -0.4000000000000008; y := 5.700000000000001; fxm := (-0.4000000000000008)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(-0.4000000000000008)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := -0.7017543859649135610957217605414805e-1; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,-0.4000000000000008,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = -0.4000000000000008\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -6.0; fxm := (0.39999999999999925)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.66666666666666541666666666666666666e-1; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -5.1; fxm := (0.39999999999999925)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.78431372549019460784313725490196078e-1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -4.199999999999999; fxm := (0.39999999999999925)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.95238095238095082199546485260733857e-1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -3.2999999999999994; fxm := (0.39999999999999925)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.12121212121212100688705234159775882e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -2.3999999999999995; fxm := (0.39999999999999925)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.16666666666666638888888888888883101e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -1.4999999999999996; fxm := (0.39999999999999925)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.2666666666666662377777777777776634e0; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := -0.5999999999999995; fxm := (0.39999999999999925)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.66666666666666597222222222222164351e0; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 0.3000000000000005; fxm := (0.39999999999999925)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.133333333333332861111111111111898148e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 1.2000000000000006; fxm := (0.39999999999999925)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.333333333333332541666666666667062499e0; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 2.1000000000000005; fxm := (0.39999999999999925)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.190476190476190073696145124716649119e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.0000000000000004; fxm := (0.39999999999999925)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.133333333333333065555555555555591259e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 3.9000000000000004; fxm := (0.39999999999999925)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.10256410256410236127547666009206551e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 4.800000000000001; fxm := (0.39999999999999925)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.833333333333331597222222222222583912e-1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 0.39999999999999925; y := 5.700000000000001; fxm := (0.39999999999999925)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(0.39999999999999925)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.70175438596491084179747614650686986e-1; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,0.39999999999999925,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 0.39999999999999925\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -6.0; fxm := (1.1999999999999993)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.19999999999999988333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -5.1; fxm := (1.1999999999999993)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.23529411764705868627450980392156862e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -4.199999999999999; fxm := (1.1999999999999993)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.28571428571428561564625850340133705e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -3.2999999999999994; fxm := (1.1999999999999993)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.36363636363636349035812672176305885e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -2.3999999999999995; fxm := (1.1999999999999993)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.49999999999999981249999999999996093e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -1.4999999999999996; fxm := (1.1999999999999993)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.79999999999999974666666666666659911e0; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := -0.5999999999999995; fxm := (1.1999999999999993)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.20000000000000005000000000000004166e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 0.3000000000000005; fxm := (1.1999999999999993)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.399999999999999100000000000001499999e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 1.2000000000000006; fxm := (1.1999999999999993)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.999999999999998916666666666667208333e0; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 2.1000000000000005; fxm := (1.1999999999999993)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.571428571428570959183673469387866861e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.0000000000000004; fxm := (1.1999999999999993)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.399999999999999713333333333333371555e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 3.9000000000000004; fxm := (1.1999999999999993)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.307692307692307481262327416173591665e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 4.800000000000001; fxm := (1.1999999999999993)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.249999999999999802083333333333374565e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.1999999999999993; y := 5.700000000000001; fxm := (1.1999999999999993)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.1999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.210526315789473524469067405355522022e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.1999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.1999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -6.0; fxm := (1.9999999999999993)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.33333333333333321666666666666666666e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -5.1; fxm := (1.9999999999999993)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.39215686274509790196078431372549019e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -4.199999999999999; fxm := (1.9999999999999993)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.47619047619047613718820861678003266e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -3.2999999999999994; fxm := (1.9999999999999993)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.6060606060606059586776859504132046e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -2.3999999999999995; fxm := (1.9999999999999993)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.83333333333333321527777777777775318e0; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -1.4999999999999996; fxm := (1.9999999999999993)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.13333333333333332222222222222221925e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := -0.5999999999999995; fxm := (1.9999999999999993)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.3333333333333334944444444444445787e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 0.3000000000000005; fxm := (1.9999999999999993)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.666666666666665322222222222224462962e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 1.2000000000000006; fxm := (1.9999999999999993)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.166666666666666525000000000000070833e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 2.1000000000000005; fxm := (1.9999999999999993)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.952380952380951820861678004535280747e0; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.0000000000000004; fxm := (1.9999999999999993)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.666666666666666344444444444444487407e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 3.9000000000000004; fxm := (1.9999999999999993)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.512820512820512588428665351742298622e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 4.800000000000001; fxm := (1.9999999999999993)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.416666666666666434027777777777826244e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 1.9999999999999993; y := 5.700000000000001; fxm := (1.9999999999999993)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.9999999999999993)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.35087719298245595598645737149895509e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,1.9999999999999993,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.9999999999999993\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -6.0; fxm := (2.7999999999999994)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.46666666666666656666666666666666666e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -5.1; fxm := (2.7999999999999994)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.54901960784313713725490196078431372e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -4.199999999999999; fxm := (2.7999999999999994)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.66666666666666668253968253968254346e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -3.2999999999999994; fxm := (2.7999999999999994)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.8484848484848484573002754820936589e0; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -2.3999999999999995; fxm := (2.7999999999999994)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.11666666666666666597222222222222207e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -1.4999999999999996; fxm := (2.7999999999999994)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.18666666666666667644444444444444705e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := -0.5999999999999995; fxm := (2.7999999999999994)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.46666666666666695555555555555579629e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 0.3000000000000005; fxm := (2.7999999999999994)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.933333333333331577777777777780703703e1; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 1.2000000000000006; fxm := (2.7999999999999994)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.233333333333333166666666666666749999e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 2.1000000000000005; fxm := (2.7999999999999994)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.133333333333333273015873015873030234e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.0000000000000004; fxm := (2.7999999999999994)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.933333333333333008888888888888932148e0; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 3.9000000000000004; fxm := (2.7999999999999994)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.717948717948717721236028928336643975e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 4.800000000000001; fxm := (2.7999999999999994)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.583333333333333086805555555555606915e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 2.7999999999999994; y := 5.700000000000001; fxm := (2.7999999999999994)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.7999999999999994)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.491228070175438405047706986765192096e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,2.7999999999999994,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.7999999999999994\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -6.0; fxm := (3.5999999999999996)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.59999999999999993333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -5.1; fxm := (3.5999999999999996)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.70588235294117639215686274509803921e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -4.199999999999999; fxm := (3.5999999999999996)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.85714285714285725170068027210886945e0; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -3.2999999999999994; fxm := (3.5999999999999996)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.10909090909090909862258953168044217e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -2.3999999999999995; fxm := (3.5999999999999996)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.15000000000000001458333333333333637e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -1.4999999999999996; fxm := (3.5999999999999996)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.24000000000000003733333333333334328e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := -0.5999999999999995; fxm := (3.5999999999999996)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.60000000000000043333333333333369444e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 0.3000000000000005; fxm := (3.5999999999999996)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.119999999999999786666666666667022222e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 1.2000000000000006; fxm := (3.5999999999999996)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.299999999999999816666666666666758333e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 2.1000000000000005; fxm := (3.5999999999999996)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.171428571428571368707482993197293164e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.0000000000000004; fxm := (3.5999999999999996)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.119999999999999970666666666666670577e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 3.9000000000000004; fxm := (3.5999999999999996)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.923076923076922879684418145956627724e0; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 4.800000000000001; fxm := (3.5999999999999996)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.749999999999999760416666666666716579e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 3.5999999999999996; y := 5.700000000000001; fxm := (3.5999999999999996)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.5999999999999996)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.631578947368420871652816251154233043e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,3.5999999999999996,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.5999999999999996\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -6.0; fxm := (4.3999999999999995)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.73333333333333325e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -5.1; fxm := (4.3999999999999995)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.86274509803921558823529411764705882e0; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -4.199999999999999; fxm := (4.3999999999999995)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.10476190476190477494331065759637498e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -3.2999999999999994; fxm := (4.3999999999999995)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.13333333333333334242424242424242589e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -2.3999999999999995; fxm := (4.3999999999999995)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.18333333333333335069444444444444806e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -1.4999999999999996; fxm := (4.3999999999999995)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.29333333333333337822222222222223419e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := -0.5999999999999995; fxm := (4.3999999999999995)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.73333333333333386111111111111155092e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 0.3000000000000005; fxm := (4.3999999999999995)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.14666666666666640555555555555599074e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 1.2000000000000006; fxm := (4.3999999999999995)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.366666666666666441666666666666779166e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 2.1000000000000005; fxm := (4.3999999999999995)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.209523809523809450113378684807273782e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.0000000000000004; fxm := (4.3999999999999995)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.146666666666666630444444444444449274e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 3.9000000000000004; fxm := (4.3999999999999995)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.112820512820512796120973044049969628e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 4.800000000000001; fxm := (4.3999999999999995)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.916666666666666371527777777777839265e0; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 4.3999999999999995; y := 5.700000000000001; fxm := (4.3999999999999995)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.3999999999999995)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.77192982456140328562634656817486217e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,4.3999999999999995,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.3999999999999995\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -6.0; fxm := (5.199999999999999)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.8666666666666665e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -5.1; fxm := (5.199999999999999)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.10196078431372547058823529411764705e1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -4.199999999999999; fxm := (5.199999999999999)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.12380952380952381519274376417233695e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -3.2999999999999994; fxm := (5.199999999999999)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.1575757575757575741046831955922862e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -2.3999999999999995; fxm := (5.199999999999999)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.21666666666666667013888888888888961e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -1.4999999999999996; fxm := (5.199999999999999)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.34666666666666669244444444444445131e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := -0.5999999999999995; fxm := (5.199999999999999)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.86666666666666722222222222222268518e1; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 0.3000000000000005; fxm := (5.199999999999999)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.173333333333333011111111111111648148e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 1.2000000000000006; fxm := (5.199999999999999)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.433333333333333033333333333333483333e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 2.1000000000000005; fxm := (5.199999999999999)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.247619047619047512471655328798211316e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.0000000000000004; fxm := (5.199999999999999)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.173333333333333276888888888888896414e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 3.9000000000000004; fxm := (5.199999999999999)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.133333333333333294017094017094021126e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 4.800000000000001; fxm := (5.199999999999999)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.108333333333333289930555555555564597e1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.199999999999999; y := 5.700000000000001; fxm := (5.199999999999999)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.199999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.912280701754385629424438288704275539e0; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.199999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.199999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -6.0; fxm := (5.999999999999999)/(-6.0); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-6.0)) * y_start_err); fxr2 := -0.99999999999999983333333333333333333e0; fxrerr := 0.166e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-6.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -6.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -5.1; fxm := (5.999999999999999)/(-5.1); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-5.1)) * y_start_err); fxr2 := -0.11764705882352939215686274509803921e1; fxrerr := 0.196e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-5.1,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -5.1\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -4.199999999999999; fxm := (5.999999999999999)/(-4.199999999999999); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-4.199999999999999)) * y_start_err); fxr2 := -0.14285714285714286734693877551020651e1; fxrerr := 0.238e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-4.199999999999999,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -4.199999999999999\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -3.2999999999999994; fxm := (5.999999999999999)/(-3.2999999999999994); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-3.2999999999999994)) * y_start_err); fxr2 := -0.18181818181818182093663911845730077e1; fxrerr := 0.303e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-3.2999999999999994,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -3.2999999999999994\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -2.3999999999999995; fxm := (5.999999999999999)/(-2.3999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-2.3999999999999995)) * y_start_err); fxr2 := -0.25000000000000001041666666666666883e1; fxrerr := 0.416e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-2.3999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -2.3999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -1.4999999999999996; fxm := (5.999999999999999)/(-1.4999999999999996); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-1.4999999999999996)) * y_start_err); fxr2 := -0.40000000000000004000000000000001066e1; fxrerr := 0.666e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-1.4999999999999996,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -1.4999999999999996\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := -0.5999999999999995; fxm := (5.999999999999999)/(-0.5999999999999995); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(-0.5999999999999995)) * y_start_err); fxr2 := -0.10000000000000006666666666666672222e2; fxrerr := 0.166e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,-0.5999999999999995,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = -0.5999999999999995\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 0.3000000000000005; fxm := (5.999999999999999)/(0.3000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(0.3000000000000005)) * y_start_err); fxr2 := 0.199999999999999633333333333333944444e2; fxrerr := 0.333e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,0.3000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 0.3000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 1.2000000000000006; fxm := (5.999999999999999)/(1.2000000000000006); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(1.2000000000000006)) * y_start_err); fxr2 := 0.499999999999999666666666666666833333e1; fxrerr := 0.833e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,1.2000000000000006,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 1.2000000000000006\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 2.1000000000000005; fxm := (5.999999999999999)/(2.1000000000000005); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(2.1000000000000005)) * y_start_err); fxr2 := 0.285714285714285598639455782312952704e1; fxrerr := 0.476e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,2.1000000000000005,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 2.1000000000000005\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.0000000000000004; fxm := (5.999999999999999)/(3.0000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.0000000000000004)) * y_start_err); fxr2 := 0.199999999999999940000000000000007999e1; fxrerr := 0.333e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,3.0000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.0000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 3.9000000000000004; fxm := (5.999999999999999)/(3.9000000000000004); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(3.9000000000000004)) * y_start_err); fxr2 := 0.153846153846153804733727810650891822e1; fxrerr := 0.256e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,3.9000000000000004,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 3.9000000000000004\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 4.800000000000001; fxm := (5.999999999999999)/(4.800000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(4.800000000000001)) * y_start_err); fxr2 := 0.124999999999999953125000000000009765e1; fxrerr := 0.208e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,4.800000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 4.800000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = division \n"): total_tests := total_tests + 1; x := 5.999999999999999; y := 5.700000000000001; fxm := (5.999999999999999)/(5.700000000000001); fffx := x -> x /y; fffy := y -> x /y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.999999999999999)) * x_start_err) + abs(evalf(gggy(5.700000000000001)) * y_start_err); fxr2 := 0.10526315789473680609418282548477086e1; fxrerr := 0.175e-13; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(division,5.999999999999999,5.700000000000001,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.999999999999999\n"): fprintf(out_fd,"y = 5.700000000000001\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(out_fd,"Operator = exponentiation\n"): fprintf(except_fd,"Operator = exponentiation\n"): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 1.0; fxm := (1.0)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.1e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 1.9; fxm := (1.0)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.100000000000000000000000000000006372e1; fxrerr := 0.19e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 2.8; fxm := (1.0)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.100000000000000000000000000000009391e1; fxrerr := 0.28e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 3.6999999999999997; fxm := (1.0)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.100000000000000000000000000000012409e1; fxrerr := 0.369e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 4.6; fxm := (1.0)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.100000000000000000000000000000015428e1; fxrerr := 0.46e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 5.5; fxm := (1.0)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.100000000000000000000000000000018447e1; fxrerr := 0.55e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.0; y := 6.4; fxm := (1.0)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.0)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.100000000000000000000000000000021465e1; fxrerr := 0.64e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.0,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.0\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 1.0; fxm := (1.8)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.18e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 1.9; fxm := (1.8)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.305504604130631438793614742477611865e1; fxrerr := 0.641e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 2.8; fxm := (1.8)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.518517017472299044301397733664766237e1; fxrerr := 0.16e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 3.6999999999999997; fxm := (1.8)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.88005186754372442553882585003563722e1; fxrerr := 0.36e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 4.6; fxm := (1.8)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.149366609671315817994049772682688454e2; fxrerr := 0.761e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 5.5; fxm := (1.8)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.253512149766499357023869368252656943e2; fxrerr := 0.154e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 1.8; y := 6.4; fxm := (1.8)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(1.8)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.430272938648442974497177692120813534e2; fxrerr := 0.305e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,1.8,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 1.8\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 1.0; fxm := (2.6)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.26e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 1.9; fxm := (2.6)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.614397388625381700006151732074368839e1; fxrerr := 0.888e-10; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 2.8; fxm := (2.6)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.145186211980649350140254110361121587e2; fxrerr := 0.31e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 3.6999999999999997; fxm := (2.6)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.343084728866623237561205883964051747e2; fxrerr := 0.974e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 4.6; fxm := (2.6)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.810732159588078803639414371212178232e2; fxrerr := 0.285e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 5.5; fxm := (2.6)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.191581431432896857348874043271639406e3; fxrerr := 0.807e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 2.6; y := 6.4; fxm := (2.6)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(2.6)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.4527197353134017219525917197584172e3; fxrerr := 0.221e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,2.6,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 2.6\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 1.0; fxm := (3.4000000000000004)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.34000000000000004e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 1.9; fxm := (3.4000000000000004)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.10228452728435107909737582815977982e2; fxrerr := 0.113e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 2.8; fxm := (3.4000000000000004)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.307709544758328208966079535283585115e2; fxrerr := 0.504e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 3.6999999999999997; fxm := (3.4000000000000004)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.925703686073189882574287848457512844e2; fxrerr := 0.199e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 4.6; fxm := (3.4000000000000004)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.278485776280522294712378564213227375e3; fxrerr := 0.75e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 5.5; fxm := (3.4000000000000004)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.837787823007904996326348668674257899e3; fxrerr := 0.269e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 3.4000000000000004; y := 6.4; fxm := (3.4000000000000004)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(3.4000000000000004)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.252037445414556297810642908684222758e4; fxrerr := 0.947e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,3.4000000000000004,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 3.4000000000000004\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 1.0; fxm := (4.2)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.42e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 1.9; fxm := (4.2)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.152817697451561831498258555570543387e2; fxrerr := 0.137e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 2.8; fxm := (4.2)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.556029729866597321172379800279418624e2; fxrerr := 0.737e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 3.6999999999999997; fxm := (4.2)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.202312340554350682027919293935215683e3; fxrerr := 0.354e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 4.6; fxm := (4.2)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.73611681070362187866237981507624625e3; fxrerr := 0.16e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 5.5; fxm := (4.2)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.267837323969320714985673134695389706e4; fxrerr := 0.696e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 4.2; y := 6.4; fxm := (4.2)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(4.2)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.974530550966181020801972487926509042e4; fxrerr := 0.295e-6; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,4.2,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 4.2\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 1.0; fxm := (5.0)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.5e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 1.9; fxm := (5.0)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.212834980630196150838941480678787866e2; fxrerr := 0.161e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 2.8; fxm := (5.0)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.905974579597119414338267501101966317e2; fxrerr := 0.101e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 3.6999999999999997; fxm := (5.0)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.385646164200005836654592241722184092e3; fxrerr := 0.569e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 4.6; fxm := (5.0)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.164157987775235452278445704156029588e4; fxrerr := 0.301e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 5.5; fxm := (5.0)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.698771242968684280127866771478521908e4; fxrerr := 0.153e-6; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.0; y := 6.4; fxm := (5.0)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.0)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.297445927924356014046273013768608061e5; fxrerr := 0.759e-6; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.0,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.0\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 1.0; fxm := (5.8)^(1.0); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(1.0)) * y_start_err); fxr2 := 0.58e1; fxrerr := 0.1e-12; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,1.0,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 1.0\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 1.9; fxm := (5.8)^(1.9); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(1.9)) * y_start_err); fxr2 := 0.282171526588741947359073563157607261e2; fxrerr := 0.183e-9; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,1.9,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 1.9\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 2.8; fxm := (5.8)^(2.8); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(2.8)) * y_start_err); fxr2 := 0.137277190374863971999413784663850084e3; fxrerr := 0.131e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,2.8,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 2.8\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 3.6999999999999997; fxm := (5.8)^(3.6999999999999997); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(3.6999999999999997)) * y_start_err); fxr2 := 0.667857144377391361779497967086618575e3; fxrerr := 0.847e-8; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,3.6999999999999997,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 3.6999999999999997\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 4.6; fxm := (5.8)^(4.6); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(4.6)) * y_start_err); fxr2 := 0.324914258572700785468265681293347597e4; fxrerr := 0.512e-7; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,4.6,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 4.6\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 5.5; fxm := (5.8)^(5.5); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(5.5)) * y_start_err); fxr2 := 0.158071641986048648092759610164485298e5; fxrerr := 0.298e-6; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,5.5,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 5.5\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): local except_flg: x_start_err := 0.1e-12; y_start_err := 0.1e-19; fprintf(out_fd,"___________________________________________________________________\n"): fprintf(out_fd,"Operator = exponentiation \n"): total_tests := total_tests + 1; x := 5.8; y := 6.4; fxm := (5.8)^(6.4); fffx := x -> x ^y; fffy := y -> x ^y; gggx := D(fffx); gggy := D(fffy); differentialm := abs(evalf(gggx(5.8)) * x_start_err) + abs(evalf(gggy(6.4)) * y_start_err); fxr2 := 0.769022698786076277029026627383296717e5; fxrerr := 0.168e-5; fxr := fxr2; abs_err := abs(fxm - fxr); except_flg := 0; if fxm <> 0.0 then percent_error := abs_err * 100.0 / abs(fxm): else percent_error := 0.0: end: if (percent_error > 1.0e-10) then except_flg := 1: fprintf(except_fd,"PERCENT ERROR > 1.0e-10\n"): end: if (abs_err > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"ABS ERROR > 1.5 * ESTIMATE\n"): end: if (differentialm > 1.5 * fxrerr and fxerr > 0.0) then except_flg := 1: fprintf(except_fd,"DIFFERENTIAL > 1.5 * ESTIMATE\n"): end: if (fxrerr > 1000.0 * differentialm and differentialm > 0.0) then except_flg := 1: fprintf(except_fd,"ESTIMATE > 1000.0 * DIFFERENTIAL\n"): end: if (except_flg = 1) then dump_except(exponentiation,5.8,6.4,fxm,fxr2,fxrerr,percent_error,abs_err,except_fd,differentialm,0.1e-12,0.1e-19): end: fprintf(out_fd,"x = 5.8\n"): fprintf(out_fd,"y = 6.4\n"): fprintf(out_fd,"error given in x = 0.1e-12\n"): fprintf(out_fd,"error given in y = 0.1e-19\n"): fprintf(out_fd,"Ruby APFP value = %40.34e\n",fxr): fprintf(out_fd,"Maple value = %40.34e\n",fxm): fprintf(out_fd,"Percent Difference = %40.34e\n",percent_error): fprintf(out_fd,"Absolute Difference = %40.34e\n",abs_err): fprintf(out_fd,"Ruby APFP error estimate = %40.34e\n",fxrerr): fprintf(out_fd,"Maple Differential = %40.34e\n",differentialm): fprintf(out_fd,"total_tests = %d\n",total_tests): fprintf(out_fd,"total_exceptions = %d\n",total_exceptions): fprintf(except_fd,"total_tests = %d\n",total_tests): fprintf(except_fd,"total_exceptions = %d\n",total_exceptions): mend := trunc(time()*1000.0): rend := 1429039448*1000: rcpuuend := 25.89*1000: rcpusend := 0.609*1000: melapsed := trunc(evalf(mend - mstart)): relapsed := trunc(evalf(rend - rstart)): rcpuuelapsed := trunc(evalf(rcpuuend - rcpuustart)): rcpuselapsed := trunc(evalf(rcpusend - rcpusstart)): mhours := hours_elapsed(melapsed): rhours := hours_elapsed(relapsed): rcpuuhours := hours_elapsed(rcpuuelapsed): rcpushours := hours_elapsed(rcpuselapsed): mmin := min_elapsed(mhours,melapsed): rmin := min_elapsed(rhours,relapsed): rcpuumin := min_elapsed(rcpuuhours,rcpuuelapsed): rcpusmin := min_elapsed(rhours,rcpuselapsed): msec := sec_elapsed(mhours,mmin,melapsed): rsec := sec_elapsed(rhours,rmin,relapsed): rcpuusec := sec_elapsed(rcpuuhours,rcpuumin,rcpuuelapsed): rcpussec := sec_elapsed(rcpushours,rcpusmin,rcpuselapsed): mmsec := msec_elapsed(mhours,mmin,msec,melapsed): rmsec := msec_elapsed(rhours,rmin,rsec,relapsed): rcpuumsec := msec_elapsed(rcpuuhours,rcpuumin,rcpuusec,rcpuuelapsed): rcpusmsec := msec_elapsed(rcpushours,rcpusmin,rcpussec,rcpuselapsed): fprintf(out_fd,"Maple %d hours %d minutes %d seconds %d msec CPU\n",mhours,mmin,msec,mmsec): fprintf(out_fd,"Ruby %d hours %d minutes %d seconds %d msec Clock\n",rhours,rmin,rsec,rmsec): fprintf(out_fd,"Ruby %d hours %d minutes %d seconds %d msec User CPU\n",rcpuuhours,rcpuumin,rcpuusec,rcpuumsec): fprintf(out_fd,"Ruby %d hours %d minutes %d seconds %d msec System CPU\n",rcpushours,rcpusmin,rcpussec,rcpusmsec): fprintf(except_fd,"Maple %d hours %d minutes %d seconds %d msec CPU\n",mhours,mmin,msec,mmsec): fprintf(except_fd,"Ruby %d hours %d minutes %d seconds %d msec Clock\n",rhours,rmin,rsec,rmsec): fprintf(except_fd,"Ruby %d hours %d minutes %d seconds %d msec User CPU\n",rcpuuhours,rcpuumin,rcpuusec,rcpuumsec): fprintf(except_fd,"Ruby %d hours %d minutes %d seconds %d msec System CPU\n",rcpushours,rcpusmin,rcpussec,rcpusmsec): printf("Maple %d hours %d minutes %d seconds %d msec CPU\n",mhours,mmin,msec,mmsec): printf("Ruby %d hours %d minutes %d seconds %d msec Clock\n",rhours,rmin,rsec,rmsec): printf("Ruby %d hours %d minutes %d seconds %d msec User CPU\n",rcpuuhours,rcpuumin,rcpuusec,rcpuumsec): printf("Ruby %d hours %d minutes %d seconds %d msec System CPU\n",rcpushours,rcpusmin,rcpussec,rcpusmsec): fprintf(out_fd,"___________________________________________________________________\n"): fclose(out_fd): fclose(except_fd):