My c++ code for factoring isn't working - c++

I am trying to create a c++ program that when I input two numbers (num1, combinationNum), it finds two numbers that multiply together to equal num1, but add together to equal combinationNum. It currently works for positive integers, but not negative. How do I make it work with negative integers? Also, If the equation isn't solvable, I would like it to print an error of some sort. Thanks!
Code:
//
// main.cpp
// Factor
//
// Created by Dani Smith on 2/13/14.
// Copyright (c) 2014 Dani Smith Productions. All rights reserved.
//
#include <iostream>
#include <cmath>
using namespace std;
void factors(int num, int comNum){
int a, b;
cout<<"The factors are ";
bool isPrime = true;
int root = (int)sqrt((double)num);
for(int i = 2; i <= root; i++){
if(num % i == 0 ){
isPrime = false;
//cout<<i<<",";
for(int x = 0; x<3; x++){
if(x==1){
a = i;
}
else if(x == 2){
b = i;
}
if(a + b == comNum){
cout << a << ", and " << b << ".";
}
}
}
}
//----------------------------------------
if(isPrime)cout<<"1 ";
cout<<endl;
}
int main(int argc, const char * argv[])
{
int num1 = 0, num2 = 0, multiple = 0, combinationNum = 0, output1 = 0, output2 = 0;
cout << "What number do you want to factor?\n";
cin >> num1;
cout << "What do you want them to add to?\n";
cin >> combinationNum;
factors(num1, combinationNum);
return 0;
}

To solve:
x + y == a
x * y == b
You have to solve
y == a - x
x * x - a * x + b == 0
So with delta == a * a - 4 * b, if delta positive, the solutions are
x1 = (a + sqrt(delta)) / 2
x2 = (a + sqrt(delta)) / 2
The code : (https://ideone.com/qwrSwa)
void solve(int sum, int mul)
{
std::cout << "solution for x + y = " << sum << std::endl
<< " x * y = " << mul << std::endl;
const int delta = sum * sum - 4 * mul;
if (delta < 0) {
std::cout << "No solution" << std::endl;
return;
}
const float sqrtdelta = sqrtf(delta);
const float x1 = (sum + sqrtdelta) / 2.f;
const float x2 = (sum - sqrtdelta) / 2.f;
std::cout << "x = " << x1 << ", y = " << sum - x1 << std::endl;
if (delta != 0) {
std::cout << "x = " << x2 << ", y = " << sum - x2 << std::endl;
}
}

Related

How to get the value of each integral independently in c++?

I am using simpson's 1/3 rule in c++ to find the integral of k*(x*x), where k=2*m and 'm' goes from 1 to 10, hence I have 10 integrals. When I wrote the code below I got the answers but its adding the values of integral from the previous ones! e.g. for m=1 => k=2 the integral is 0.66667, now for m=2 => k=4 instead of getting 0.33333, the integral is 2.00 (0.66667+0.33333). How to prevent it from doing that?
#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;
int k;
double f(double x) {
return k * pow(x, 2);
}
int main() {
int n = 100000, m;
double h, a = 0, b = 1, sum = 0, x, y;
cout << "The number of sub-intervals is n = " << n << endl;
cout << fixed << showpoint << setprecision(5);
for (m = 1; m <= 10; m++) {
cout << "m = " << m << endl;
k = 2 * m;
cout << "k = " << k << endl;
h = (b - a) / n;
for (int i = 1; i <= n; i++) {
x = a + i * h;
if (i % 2 == 0) {
sum = sum + 2 * f(x);
} else {
sum = sum + 4 * f(x);
}
}
y = h / 3.0 * (f(a) + sum + f(b));
cout << "The integration is: " << y << endl;
}
}

My function factoring program has problems with variables, shows incorrect answers

I'm making a program that factors functions (f(x), not fully factored though):
#include <iostream>
#include <math.h>
#include <stdio.h>
using namespace std;
int x3;
int x2;
int x;
int remain;
int r = 0;
int factor;
int main() {
int b, i, j = 0;
int factors[101];
cout << "f(x) = x^3 + x^2 + x + r (Factor tool)" << endl;
cout << "x^3?: ";
cin >> x3;
cout << "x^2: ";
cin >> x2;
cout << "x: ";
cin >> x;
printf("remain (Y intercept): ");
scanf("%d", &b);
cout << "f(x) = " << x3 << "x^3 + " << x2 << "x^2 + " << x << "x + " << b
<< "" << endl;
cout << "factors of remainder are: " << endl;
for (i = 1; i <= b; i++) {
if (b % i == 0) {
factors[j++] = i;
printf("%d\t", i);
}
}
getchar();
while (true) {
int good;
if (factors[1] == 0) {
cout <<endl;
cout << "Equation Cannot be factored";
break;
}
int factorv = factors[r];
int nx1 = x3 * factors[r];
int nx2 = (nx1 + x2);
int nx3 = x + (nx2 * factors[r]);
int nx4 = remain + (nx3 * factors[r]);
if (nx4 == 0) {
int factored = (0 - factors[r]);
cout <<endl;
cout << "The Factored Function: f(x) = "
<< "(x " << factored << ")(" << nx1 << "x^3 + " << nx2 << "x^2 + "
<< nx3 << "x"
<< ")"
<< "";
break;
} else {
r = r + 1;
}
}
}
but in this part of the code, it shows as (x 0)(0x^3 + (x3 input instead of calculated nx1)x^2 + (x2 input instead of calculated nx2)x).
if (nx4 == 0) {
int factored = (0-factors[r]);
cout<<"The Factored Function: f(x) = "<<"(x "<<factored<<")("<<nx1<<"x^3 + "<<nx2<<"x^2 + "<<nx3<<"x"<<")"<<"";
break;
What happen to my nx variables? Why is it coming up incorrect or as a 0 when it was calculated properly above?
You have some of your variables twice:
int nx1;
int nx2;
int nx3;
int nx4;
They exists as global variables and again in the scope of main. They have the same name but are different variables.
Take the lesson: Global variables are no good.
Moreover you have a logic error in your code. When I add a std::cout << r << std::endl; in the last while loop I see its value increasing until there is a segfault, because factors[r] is out-of-bounds. broken code # wandbox
I cannot really tell you how to fix it, because I would have to dive into the maths first. I can only suggest you to never use infinte loops in numerical codes without an "emergency exit". What i mean is that unless fully tested, you cannot be sure that the loop will end at some point and when it doesn't typically the consequences are bad and difficult to diagnose. Always make sure the loop will end at some point:
int max_iteratons = 100;
int counter;
while (counter < max_iteratons) {
// do something
++counter;
}
if (counter == max_iterations) std::cout << "i have a bug :(";

Fractions instead of decimals

So, I am Writing this little program in c++, it's made to compute various values with lines (sorry i am french, i don't know how to say it in English, but they are the lines with equation types Y = kx + t).
And I want my program to output fractions instead of decimals (2/3 instead of 0.666666666...).
Can anyone tell me how ?
I read online that there are some libraries for that purpose, can anyone help me on how to use them and/or how to implement them in my code ?
Thanks :)
#include "pch.h"
#include <iostream>
#include <string>
std::string mainAnswer;
bool endVar = false;
void lineEquationFromTwoPoints() {
mainAnswer.clear();
double Xa = 0;
double Ya = 0;
double Xb = 0;
double Yb = 0;
double Y = 0;
double X = 0;
double k = 0;
double t = 0;
std::cout << ("Enter the Coordinates of your first point in this format x y : ");
std::cin >> Xa >> Ya;
std::cout << ("Enter the Coordinates of your second point in this format x y : ");
std::cin >> Xb >> Yb;
if (Xb != Xa && Yb != Ya) {
k = (Yb - Ya) / (Xb - Xa);
t = -(Xa)*k + Ya;
if (k != 1 && t != 0) {
std::cout << ("Y = ") << k << ("x + ") << t << std::endl;
}
else if (k == 1) {
std::cout << ("Y = ") << ("x") << ("+") << t << std::endl;
}
else if (t == 0) {
std::cout << ("Y = ") << k << ("x") << std::endl;
}
}
else if (Xb == Xa) {
std::cout << ("Coordinates of the first point are Equal");
}
else if (Yb == Ya) {
std::cout << ("Coordinates of the second point are Equal");
}
else if (Xb == Xa && Yb == Ya) {
std::cout << ("Coordinates of both points are Equal");
}
}
void triangle() {
double Xa = 0;
double Ya = 0;
double Xb = 0;
double Yb = 0;
double Xc = 0;
double Yc = 0;
double Ym1 = 0;
double Xm1 = 0;
double km1 = 0;
double tm1 = 0;
double Ym2 = 0;
double Xm2 = 0;
double km2 = 0;
double tm2 = 0;
double Ym3 = 0;
double Xm3 = 0;
double km3 = 0;
double tm3 = 0;
std::cout << ("Work in progress. . . :-)") << std::endl;
}
void Choose() {
while (endVar != true) {
std::cout << ("Lines:") << std::endl;
std::cout << ("------") << std::endl << std::endl;
std::cout << ("Choose What Line Operations do You Want Me To Perform:") << std::endl;
std::cout << ("1.Formulas") << std::endl;
std::cout << ("2.Calculation of a Line's equation from 2 points") << std::endl;
std::cout << ("3.Calculation of all data in a triangle") << std::endl;
std::cout << ("Type Exit to Exit") << std::endl << std::endl;
std::getline(std::cin, mainAnswer);
if (mainAnswer == "exit" || mainAnswer == "Exit") {
std::exit;
endVar = true;
}
else if (mainAnswer == "1") {
std::cout << ("Formulas will be added Here once main program with main calculation functions will be finished") << std::endl;
}
else if (mainAnswer == "2") {
lineEquationFromTwoPoints();
}
else if (mainAnswer == "3") {
triangle();
}
else {
std::cout << ("Unexpected error occured. Please relaunch program.");
std::exit;
}
}
}
int main()
{
Choose();
return 0;
}
A nice way to approximate a float with a fraction is to used continued fractions. In the following code, epsis the desired precision. xis assumed to be strictly positive.
#include <iostream>
#include <iomanip>
#include <cmath>
#include <tuple>
#include <vector>
#include <cmath>
// Continued fraction
std::pair<int, int> fract_cont (double x, double eps = 1.0e-3) {
std::vector<int> a;
std::vector<int> b;
a.push_back(1);
b.push_back(0);
int q = int(x);
a.push_back(q);
b.push_back(1);
double err = x - q;
double e = (x != q) ? 1.0 / (x - q) : 0.0;
int i = 1;
while (std::abs(err) > eps) {
i++;
q = int (e);
e = 1.0 / (e - q);
a.push_back (q * a[i-1] + a [i-2]);
b.push_back (q * b[i - 1] + b[i-2]);
err = x - double (a[i]) / b[i];
}
return std::make_pair(a[i], b[i]);
}
int main() {
int a, b;
double x = 4 * atan(1.0);
std::tie (a,b) = fract_cont(x);
std::cout <<"Pi = " << std::setprecision(9) << x << " ~= " << a << "/" << b << "\n";
return 0;
}
Detailed information on continued fractions is available on Wikipedia for example.
If you don't need a high precision or if you assume that the denominators will be small, you can use a brute force approach instead, simply incrementing the denominator b.

Formatting the output of a C++ program

I have already written most of the code for the problem and it works. I'm just unsure of how to format the output.
Problem : Design and develop a C++ program for Calculating e(n) when delta <= 0.000001
e(n-1) = 1 + 1/1! + 1/2! + 1/3! + 1/4! + … + 1/(n-1)!
e(n) = 1 + 1/1! + 1/2! + 1/3! + 1/4! + … + 1/(n)!
delta = e(n) – e(n-1)
You do not have any input to the program. Your output should be something like this:
N = 2 e(1) = 2 e(2) = 2.5 delta = 0.5
N = 3 e(2) = 2.5 e(3) = 2.565 delta = 0.065
#include <iostream>
using namespace std;
//3! = 3 * 2!
//2! = 2 * 1!
//1! = 1
int factorial(int number)
{
//if number is <= 1, return 1
if (number <= 1)
{
return 1;
}
// otherwise multiply number by factorial(number - 1)
else
{
//otherwise multiply number by factorial(number - 1) and return it
int temp = number * factorial(number - 1);
cout << "factorial of " << number << " = " << temp << endl;
return temp;
}
}
double sumOfFactorials(int n)
{
double sum = 0;
//loop from 1..n, adding the factorial division to a sum
for (int i = 1; i <= n; i++)
{
double dividedValue = 1.00000 / factorial(i);
cout << fixed;
sum = sum + dividedValue;
}
return sum;
}
/**
* Compute the sum of 1 + ... + 1/(n!)
* input number: 1
* output number: 1 + ... + 1/(input!)
*/
double e(int n)
{
double value = 1 + sumOfFactorials(n);
return value;
}
int main()
{
cout << "e:" << e(3) << endl; // 1 + sumOfFactorials(3)
cout << "sumOfFactorials: " << sumOfFactorials(3) << endl; //0 + 1/1! + 1/2! + 1/3!
}
You have the right code, All you need is to format the output. Just modify the main() method. here is a snippet you can try.
NOTE : There is an error in the precision of the answer, I think you can correct it.
PS : Please uncomment your debugging cout lines.
int main()
{
for(int i = 2; i<4; i++){
double en_1 = e(i-1);
double en = e(i);
double delta = en - en_1;
cout << "N = "<<i;
cout << " e("<< (i-1) <<") = " << en_1;
cout << " e("<< (i) <<") = " << en;
cout << "delta = " << delta;
cout << "\n";
}
}

Organizing text file output into columns

Everything is working like it's supposed too, except when I output to the text file I can not figure out how to keep all the output lined up. My teacher wouldn't help me and I've literally been doing trial and error with "fixed, setprecision, left, setw(), etc" for a few hours now.
//Project #5
//Start Date: November 17th
//Due Date: November 23rd
#include <iostream>
#include <string>
#include <fstream>
#include <cstdlib>
#include <cmath>
#include <iomanip>
using namespace std;
double f = 3.14159;
double upperBound = 0;
double lowerBound = 0;
double increment = 0;
double tempVal = 0;
double powVal = 0;
double expVal = 0;
double fact = 0;
double sinVal = 0;
double x = 0.0;
char userCont = 'Y';
int n = 0;
int i = 0;
//Factorial function using recursion...
double factorial(const int n) {
if (n <= 1) return 1;
fact = n * factorial(n - 1);
return fact;
}
//Power function using recursion...
double power(const double x, const int n) {
if (n <= 0)
return 1;
powVal = x * power(x, n - 1);
return powVal;
}
//my_sin function using power and factorial functions
double my_sin(const double x) {
sinVal = 0;
for (int k = 0; k < 50; k++) {
sinVal += power(-1, k) * (power(x, 2 * k + 1) / factorial(2 * k + 1));
}
return sinVal;
}
//my_exp(x) Function
double my_exp(const double x) {
expVal = 0;
for (int k = 0; k < 50; k++) {
expVal += power(x, k) / factorial(k);
}
return expVal;
}
int main() {
ofstream fout("output.text");
while (userCont == 'y' || userCont == 'Y') {
cout << "Enter lower and upper bounds: ";
cin >> upperBound >> lowerBound;
cout << "Enter Increment: ";
cin >> increment;
//Checking if upper and lower bounds are in the right order...
if (upperBound < lowerBound) {
tempVal = upperBound;
upperBound = lowerBound;
lowerBound = tempVal;
}
fout << "x sin(x) my_sin(x) e(x) " <<
"my_el(x) my_exp(x)" << endl;
//Loop to display and increase x by the incrememnt
for (x = lowerBound; x <= upperBound; x = x + increment) {
fout.precision(7);
fout << setw(8) << left << x << " ";
fout << setw(8) << my_sin(x) << setw(8) << " ";
fout << setw(8) << sin(x) << setw(8) << " ";
fout << setw(8) << exp(x) << setw(8) << " ";
fout << setw(8) << exp(x) << setw(8) << " ";
fout << my_exp(x) << endl;
}
cout << "Another (y/n)? ";
cin >> userCont;
}
return 0;
}
Here's how it's supposed to look
Some cleanup and the best I could to mimick the formatting, hopefully it is of some inspiration/assistance.
Important Note how I removed all the global variables. They're bad :(
Live On Coliru
// Project #5
// Start Date: November 17th
// Due Date: November 23rd
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
double factorial(const int n) {
if (n <= 1)
return 1;
return n * factorial(n - 1);
}
double power(const double x, const int n) {
if (n <= 0)
return 1;
return x * power(x, n - 1);
}
// my_sin function using power and factorial functions
double my_sin(const double x) {
double sinVal = 0;
for (int k = 0; k < 50; k++) {
sinVal += power(-1, k) * (power(x, 2 * k + 1) / factorial(2 * k + 1));
}
return sinVal;
}
// my_exp(x) Function
double my_exp(const double x) {
double expVal = 0;
for (int k = 0; k < 50; k++) {
expVal += power(x, k) / factorial(k);
}
return expVal;
}
int main() {
ofstream fout("output.text");
char userCont = 'Y';
while (userCont == 'y' || userCont == 'Y') {
cout << "Enter lower and upper bounds: ";
double upperBound, lowerBound;
cin >> upperBound >> lowerBound;
cout << "Enter Increment: ";
double increment = 0;
cin >> increment;
// Checking if upper and lower bounds are in the right order...
if (upperBound < lowerBound) {
std::swap(upperBound, lowerBound);
}
fout << " x sin(x) my_sin(x) e(x) my_el(x) my_exp(x)" << endl;
// Loop to display and increase x by the incrememnt
for (double x = lowerBound; x <= upperBound; x = x + increment) {
fout.precision(7);
fout << right << std::fixed << std::setprecision(7) << setw(12) << x << " ";
fout << right << std::fixed << std::setprecision(7) << setw(12) << my_sin(x) << setw(4) << " ";
fout << right << std::fixed << std::setprecision(7) << setw(12) << sin(x) << setw(4) << " ";
fout << right << std::fixed << std::setprecision(7) << setw(12) << exp(x) << setw(4) << " ";
fout << right << std::fixed << std::setprecision(7) << setw(12) << exp(x) << setw(4) << " ";
fout << my_exp(x) << endl;
}
cout << "Another (y/n)? ";
cin >> userCont;
}
}
Output:
x sin(x) my_sin(x) e(x) my_el(x) my_exp(x)
0.0000000 0.0000000 0.0000000 1.0000000 1.0000000 1.0000000
0.1000000 0.0998334 0.0998334 1.1051709 1.1051709 1.1051709
0.2000000 0.1986693 0.1986693 1.2214028 1.2214028 1.2214028
0.3000000 0.2955202 0.2955202 1.3498588 1.3498588 1.3498588
0.4000000 0.3894183 0.3894183 1.4918247 1.4918247 1.4918247
0.5000000 0.4794255 0.4794255 1.6487213 1.6487213 1.6487213
0.6000000 0.5646425 0.5646425 1.8221188 1.8221188 1.8221188
0.7000000 0.6442177 0.6442177 2.0137527 2.0137527 2.0137527
0.8000000 0.7173561 0.7173561 2.2255409 2.2255409 2.2255409
0.9000000 0.7833269 0.7833269 2.4596031 2.4596031 2.4596031
1.0000000 0.8414710 0.8414710 2.7182818 2.7182818 2.7182818
1.1000000 0.8912074 0.8912074 3.0041660 3.0041660 3.0041660
1.2000000 0.9320391 0.9320391 3.3201169 3.3201169 3.3201169
1.3000000 0.9635582 0.9635582 3.6692967 3.6692967 3.6692967
1.4000000 0.9854497 0.9854497 4.0552000 4.0552000 4.0552000
1.5000000 0.9974950 0.9974950 4.4816891 4.4816891 4.4816891
1.6000000 0.9995736 0.9995736 4.9530324 4.9530324 4.9530324
1.7000000 0.9916648 0.9916648 5.4739474 5.4739474 5.4739474
1.8000000 0.9738476 0.9738476 6.0496475 6.0496475 6.0496475
1.9000000 0.9463001 0.9463001 6.6858944 6.6858944 6.6858944
2.0000000 0.9092974 0.9092974 7.3890561 7.3890561 7.3890561
2.1000000 0.8632094 0.8632094 8.1661699 8.1661699 8.1661699
2.2000000 0.8084964 0.8084964 9.0250135 9.0250135 9.0250135
2.3000000 0.7457052 0.7457052 9.9741825 9.9741825 9.9741825
2.4000000 0.6754632 0.6754632 11.0231764 11.0231764 11.0231764
2.5000000 0.5984721 0.5984721 12.1824940 12.1824940 12.1824940
2.6000000 0.5155014 0.5155014 13.4637380 13.4637380 13.4637380
2.7000000 0.4273799 0.4273799 14.8797317 14.8797317 14.8797317
2.8000000 0.3349882 0.3349882 16.4446468 16.4446468 16.4446468
2.9000000 0.2392493 0.2392493 18.1741454 18.1741454 18.1741454
3.0000000 0.1411200 0.1411200 20.0855369 20.0855369 20.0855369
3.1000000 0.0415807 0.0415807 22.1979513 22.1979513 22.1979513
3.2000000 -0.0583741 -0.0583741 24.5325302 24.5325302 24.5325302
3.3000000 -0.1577457 -0.1577457 27.1126389 27.1126389 27.1126389
3.4000000 -0.2555411 -0.2555411 29.9641000 29.9641000 29.9641000
3.5000000 -0.3507832 -0.3507832 33.1154520 33.1154520 33.1154520
3.6000000 -0.4425204 -0.4425204 36.5982344 36.5982344 36.5982344
3.7000000 -0.5298361 -0.5298361 40.4473044 40.4473044 40.4473044
3.8000000 -0.6118579 -0.6118579 44.7011845 44.7011845 44.7011845
3.9000000 -0.6877662 -0.6877662 49.4024491 49.4024491 49.4024491
4.0000000 -0.7568025 -0.7568025 54.5981500 54.5981500 54.5981500
4.1000000 -0.8182771 -0.8182771 60.3402876 60.3402876 60.3402876
4.2000000 -0.8715758 -0.8715758 66.6863310 66.6863310 66.6863310
4.3000000 -0.9161659 -0.9161659 73.6997937 73.6997937 73.6997937
4.4000000 -0.9516021 -0.9516021 81.4508687 81.4508687 81.4508687
4.5000000 -0.9775301 -0.9775301 90.0171313 90.0171313 90.0171313
4.6000000 -0.9936910 -0.9936910 99.4843156 99.4843156 99.4843156
4.7000000 -0.9999233 -0.9999233 109.9471725 109.9471725 109.9471725
4.8000000 -0.9961646 -0.9961646 121.5104175 121.5104175 121.5104175
4.9000000 -0.9824526 -0.9824526 134.2897797 134.2897797 134.2897797
5.0000000 -0.9589243 -0.9589243 148.4131591 148.4131591 148.4131591
5.1000000 -0.9258147 -0.9258147 164.0219073 164.0219073 164.0219073
5.2000000 -0.8834547 -0.8834547 181.2722419 181.2722419 181.2722419
5.3000000 -0.8322674 -0.8322674 200.3368100 200.3368100 200.3368100
5.4000000 -0.7727645 -0.7727645 221.4064162 221.4064162 221.4064162
5.5000000 -0.7055403 -0.7055403 244.6919323 244.6919323 244.6919323
5.6000000 -0.6312666 -0.6312666 270.4264074 270.4264074 270.4264074
5.7000000 -0.5506855 -0.5506855 298.8674010 298.8674010 298.8674010
5.8000000 -0.4646022 -0.4646022 330.2995599 330.2995599 330.2995599
5.9000000 -0.3738767 -0.3738767 365.0374679 365.0374679 365.0374679
6.0000000 -0.2794155 -0.2794155 403.4287935 403.4287935 403.4287935
6.1000000 -0.1821625 -0.1821625 445.8577701 445.8577701 445.8577701
6.2000000 -0.0830894 -0.0830894 492.7490411 492.7490411 492.7490411
6.3000000 0.0168139 0.0168139 544.5719101 544.5719101 544.5719101
6.4000000 0.1165492 0.1165492 601.8450379 601.8450379 601.8450379
6.5000000 0.2151200 0.2151200 665.1416330 665.1416330 665.1416330
6.6000000 0.3115414 0.3115414 735.0951892 735.0951892 735.0951892
6.7000000 0.4048499 0.4048499 812.4058252 812.4058252 812.4058252
6.8000000 0.4941134 0.4941134 897.8472917 897.8472917 897.8472917
6.9000000 0.5784398 0.5784398 992.2747156 992.2747156 992.2747156
7.0000000 0.6569866 0.6569866 1096.6331584 1096.6331584 1096.6331584
7.1000000 0.7289690 0.7289690 1211.9670745 1211.9670745 1211.9670745
7.2000000 0.7936679 0.7936679 1339.4307644 1339.4307644 1339.4307644
7.3000000 0.8504366 0.8504366 1480.2999276 1480.2999276 1480.2999276
7.4000000 0.8987081 0.8987081 1635.9844300 1635.9844300 1635.9844300
7.5000000 0.9380000 0.9380000 1808.0424145 1808.0424145 1808.0424145
7.6000000 0.9679197 0.9679197 1998.1958951 1998.1958951 1998.1958951
7.7000000 0.9881682 0.9881682 2208.3479919 2208.3479919 2208.3479919
7.8000000 0.9985433 0.9985433 2440.6019776 2440.6019776 2440.6019776
7.9000000 0.9989413 0.9989413 2697.2823283 2697.2823283 2697.2823283
8.0000000 0.9893582 0.9893582 2980.9579870 2980.9579870 2980.9579870
8.1000000 0.9698898 0.9698898 3294.4680753 3294.4680753 3294.4680753
8.2000000 0.9407306 0.9407306 3640.9503073 3640.9503073 3640.9503073
8.3000000 0.9021718 0.9021718 4023.8723938 4023.8723938 4023.8723938
8.4000000 0.8545989 0.8545989 4447.0667477 4447.0667477 4447.0667477
8.5000000 0.7984871 0.7984871 4914.7688403 4914.7688403 4914.7688403
8.6000000 0.7343971 0.7343971 5431.6595914 5431.6595914 5431.6595914
8.7000000 0.6629692 0.6629692 6002.9122173 6002.9122173 6002.9122173
8.8000000 0.5849172 0.5849172 6634.2440063 6634.2440063 6634.2440063
8.9000000 0.5010209 0.5010209 7331.9735392 7331.9735392 7331.9735392
9.0000000 0.4121185 0.4121185 8103.0839276 8103.0839276 8103.0839276
9.1000000 0.3190984 0.3190984 8955.2927035 8955.2927035 8955.2927035
9.2000000 0.2228899 0.2228899 9897.1290587 9897.1290587 9897.1290587
9.3000000 0.1244544 0.1244544 10938.0192082 10938.0192082 10938.0192082
9.4000000 0.0247754 0.0247754 12088.3807302 12088.3807302 12088.3807302
9.5000000 -0.0751511 -0.0751511 13359.7268297 13359.7268297 13359.7268297
9.6000000 -0.1743268 -0.1743268 14764.7815656 14764.7815656 14764.7815656
9.7000000 -0.2717606 -0.2717606 16317.6071980 16317.6071980 16317.6071980
9.8000000 -0.3664791 -0.3664791 18033.7449278 18033.7449278 18033.7449278
9.9000000 -0.4575359 -0.4575359 19930.3704382 19930.3704382 19930.3704382
10.0000000 -0.5440211 -0.5440211 22026.4657948 22026.4657948 22026.4657948