How can I read two columns of numbers in a text file? - c

Question

My .txt looks like this for example:
1.0 2.0
1.0 1.0
2.0 3.0
2.0 1.0
I want to run through this file using each line when its needed. To explain I have an equation (L = Ax + B) which I need to calculate for different x's. Is there a way to read each line in the file seperately, taking A and B at that line. So the first term of L will use the first A and B.
I haven't done this before. This is what I know already:
void coefficients(double *A, double *B) {
FILE *infile;
if(2!=fscanf(infile,"%lf %lf",A, B)) {
printf("Error reading parameters from file\n");
exit(1);
}
fclose(infile);
}
And then calling this in int_main:
double A;
double B;
// Read in from file;
coefficients(&A, &B);

Answer 1

You can use this method to read a text file(file.txt) to a char array (buffer) line by line by using fgets() then parse it with sscanf() to find double value in it.
Code
double a=0;
double b=0;
int bufferLength = 1024;
char buffer[bufferLength];
FILE *fp = fopen("file.txt", "r");
if (!fp){
printf("Cant open file\n");
return -1;
}
while(fgets(buffer, bufferLength, fp)) {
//printf("%s\n", buffer);
if (2==sscanf(buffer, "%lf %lf", &a,&b)){
printf("a: %f b: %f\n", a,b);
}
}
fclose(fp);

Answer 2

With a file with potential blank lines and potential lines that contain something other than the pair of double values you are looking for, you are much better off reading each line into a buffer and the parsing the wanted values from the buffer with sscanf rather than attempting to read directly with fscanf. This way a line of input is consumed on each read and you don't have to worry about what remains in your input stream depending on the conversion specifiers used.
Further, in order to read multiple values into A and B, both A and B must be arrays of double (or an allocated block of memory that can hold multiple double values)
For example in main() can declare:
#include <stdio.h>
#define MAXC 1024 /* if you need a constant, #define one (or more) */
...
int main (int argc, char **argv) {
double a[MAXC] = {0}, b[MAXC] = {0}; /* arrays of MAXC doubles */
Now you have storage for 1024 double values. Your coefficient function that reads the double values should return the number of values read. It should also take the open and validated FILE* stream as a parameter. (if the file cannot be opened in validated in the caller -- there is no reason to make the function call to attempt the read to begin with)
Putting that together you could do:
size_t coefficients (FILE *fp, double *a, double *b)
{
char buf[MAXC]; /* buffer for reading each line */
size_t ncoeff = 0; /* number of coefficient pairs read */
while (ncoeff < MAXC && fgets (buf, MAXC, fp)) /* read each line */
/* if it contains 2 double values */
if (sscanf (buf, "%lf %lf", &a[ncoeff], &b[ncoeff]) == 2)
ncoeff++; /* increment counter */
return ncoeff; /* return total count of pairs read */
}
A short example putting it altogether, you would have:
#include <stdio.h>
#define MAXC 1024 /* if you need a constant, #define one (or more) */
size_t coefficients (FILE *fp, double *a, double *b)
{
char buf[MAXC]; /* buffer for reading each line */
size_t ncoeff = 0; /* number of coefficient pairs read */
while (ncoeff < MAXC && fgets (buf, MAXC, fp)) /* read each line */
/* if it contains 2 double values */
if (sscanf (buf, "%lf %lf", &a[ncoeff], &b[ncoeff]) == 2)
ncoeff++; /* increment counter */
return ncoeff; /* return total count of pairs read */
}
int main (int argc, char **argv) {
double a[MAXC] = {0}, b[MAXC] = {0}; /* arrays of MAXC doubles */
size_t n = 0; /* count of doubles returned */
/* use filename provided as 1st argument (stdin by default) */
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) { /* validate file open for reading */
perror ("file open failed");
return 1;
}
if (!(n = coefficients (fp, a, b))) { /* validate coeff pairs read */
fputs ("error: no double values read from file.\n", stderr);
return 1;
}
if (fp != stdin) /* close file if not stdin */
fclose (fp);
for (size_t i = 0; i < n; i++) /* output coefficients */
printf ("a[%zu] : %.1f b[%zu] : %.1f\n", i, a[i], i, b[i]);
}
(you can adjust the size of the arrays as needed)
Example Input File
$ cat dat/coeffpairs.txt
A B
1.0 2.0
1.0 1.0
2.0 3.0
2.0 1.0
Example Use/Output
$ ./bin/readcoeff dat/coeffpairs.txt
a[0] : 1.0 b[0] : 2.0
a[1] : 1.0 b[1] : 1.0
a[2] : 2.0 b[2] : 3.0
a[3] : 2.0 b[3] : 1.0
Look things over and let me know if you have further questions.

Answer 3

It depends on what you want to do. If you just want to read the data and don't care what happens when it is not in the form of two columns, you can just read it with fscanf in a loop:
double A, B;
while(fscanf(fp, "%ld%ld", &A, &B) == 2) {
// do something with A and B
This will read any sequence of numbers in the file -- maybe in two columns or all on one line or randomly split between lines with blank lines, and will stop when it gets to anything that is not a number (or the end of the file, and will ignore any odd single number at the end).
If on the other hand you want to verify that the numbers are two per line and no blank lines, you can use fgets+sscanf:
char line[256];
while (fgets(line, sizeof line, fp)) {
double A, B;
int end;
if (sscanf(line, "%ld%ld %n", &A, &B, &len) == 2 && line[end] == 0) {
// got a line with (just) a pair of numbers
} else {
fprintf(stderr, "malformed input line: %s", line);
}
}
If you also want to check that the numbers are lined up in columns, that is a bit trickier. You can check for left- or right-aligned columns pretty easily
char line[256];
int a_col = -1, b_col = -1, lineno = 0;
while (fgets(line, sizeof line, fp)) {
double A, B;
int a_right, b_right, end;
++lineno;
if (sscanf(line, "%ld%n%ld%n %n", &A, &a_right, &B, &b_right, &len) == 2 && line[end] == 0) {
// got a line with (just) a pair of numbers
if (a_col >= 0 && (a_col != a_right || b_col != b_right)) {
fprintf(stderr, "columns on line %d not lined up with previous line\n", lineno);
}
a_col = a_right;
b_col = b_right;
} else {
fprintf(stderr, "malformed input on line %d", lineno);
}
}