void r8vec_data_read ( char *input_filename, int n, double x[] )
/******************************************************************************/
/*
Purpose:
R8VEC_DATA_READ reads the data from an R8VEC file.
Discussion:
An R8VEC is a vector of R8's.
The file is assumed to contain one record per line.
Records beginning with the '#' character are comments, and are ignored.
Blank lines are also ignored.
There are assumed to be exactly (or at least) N such records.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
16 July 2014
Author:
John Burkardt
Parameters:
Input, char *INPUT_FILENAME, the name of the input file.
Input, int N, the number of points.
Output, double X[N], the data.
*/
{
# define LINE_MX 255
int error;
char *got_string;
FILE *input;
int i;
int j;
int lchar;
char line[255];
input = fopen ( input_filename, "r" );
if ( !input )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "R8VEC_DATA_READ - Fatal error!\n" );
fprintf ( stderr, " Could not open the input file: \"%s\"\n", input_filename );
exit ( 1 );
}
j = 0;
while ( j < n )
{
got_string = fgets ( line, LINE_MX, input );
if ( !got_string )
{
break;
}
if ( line[0] == '#' || s_len_trim ( line ) == 0 )
{
continue;
}
x[j] = atof ( line );
j = j + 1;
}
fclose ( input );
return;
# undef LINE_MX
}
int s_to_i4 ( char *s, int *last, int *error )
/******************************************************************************/
/*
Purpose:
S_TO_I4 reads an I4 from a string.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
13 June 2003
Author:
John Burkardt
Parameters:
Input, char *S, a string to be examined.
Output, int *LAST, the last character of S used to make IVAL.
Output, int *ERROR is TRUE (1) if an error occurred and FALSE (0) otherwise.
Output, int *S_TO_I4, the integer value read from the string.
If the string is blank, then IVAL will be returned 0.
*/
{
char c;
int i;
int isgn;
int istate;
int ival;
*error = 0;
istate = 0;
isgn = 1;
i = 0;
ival = 0;
while ( *s )
{
c = s[i];
i = i + 1;
/*
Haven't read anything.
*/
if ( istate == 0 )
{
if ( c == ' ' )
{
}
else if ( c == '-' )
{
istate = 1;
isgn = -1;
}
else if ( c == '+' )
{
istate = 1;
isgn = + 1;
}
else if ( '0' <= c && c <= '9' )
{
istate = 2;
ival = c - '0';
}
else
{
*error = 1;
return ival;
}
}
/*
Have read the sign, expecting digits.
*/
else if ( istate == 1 )
{
if ( c == ' ' )
{
}
else if ( '0' <= c && c <= '9' )
{
istate = 2;
ival = c - '0';
}
else
{
*error = 1;
return ival;
}
}
/*
Have read at least one digit, expecting more.
*/
else if ( istate == 2 )
{
if ( '0' <= c && c <= '9' )
{
ival = 10 * (ival) + c - '0';
}
else
{
ival = isgn * ival;
*last = i - 1;
return ival;
}
}
}
/*
If we read all the characters in the string, see if we're OK.
*/
if ( istate == 2 )
{
ival = isgn * ival;
*last = s_len_trim ( s );
}
else
{
*error = 1;
*last = 0;
}
return ival;
}
int file_row_count ( char *input_filename )
/******************************************************************************/
/*
Purpose:
FILE_ROW_COUNT counts the number of row records in a file.
Discussion:
It does not count lines that are blank, or that begin with a
comment symbol '#'.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
13 June 2003
Author:
John Burkardt
Parameters:
Input, char *INPUT_FILENAME, the name of the input file.
Output, int FILE_ROW_COUNT, the number of rows found.
*/
{
# define LINE_MX 255
int bad_num;
int comment_num;
char *error;
FILE *input;
int i;
char line[LINE_MX];
int record_num;
int row_num;
row_num = 0;
comment_num = 0;
record_num = 0;
bad_num = 0;
input = fopen ( input_filename, "r" );
if ( !input )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "FILE_ROW_COUNT - Fatal error!\n" );
fprintf ( stderr, " Could not open the input file: \"%s\"\n",
input_filename );
exit ( 1 );
}
for ( ; ; )
{
error = fgets ( line, LINE_MX, input );
if ( !error )
{
break;
}
record_num = record_num + 1;
if ( line[0] == '#' )
{
comment_num = comment_num + 1;
continue;
}
if ( s_len_trim ( line ) == 0 )
{
comment_num = comment_num + 1;
continue;
}
row_num = row_num + 1;
}
fclose ( input );
return row_num;
# undef LINE_MX
}
int *i4mat_data_read ( char *input_filename, int m, int n )
/******************************************************************************/
/*
Purpose:
I4MAT_DATA_READ reads the data from an I4MAT file.
Discussion:
An I4MAT is an array of I4's.
The file is assumed to contain one record per line.
Records beginning with the '#' character are comments, and are ignored.
Blank lines are also ignored.
Each line that is not ignored is assumed to contain exactly (or at least)
M real numbers, representing the coordinates of a point.
There are assumed to be exactly (or at least) N such records.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
28 May 2008
Author:
John Burkardt
Parameters:
Input, char *INPUT_FILENAME, the name of the input file.
Input, int M, the number of spatial dimensions.
Input, int N, the number of points. The program
will stop reading data once N values have been read.
Output, int I4MAT_DATA_READ[M*N], the table data.
*/
{
# define LINE_MAX 255
int error;
char *got_string;
FILE *input;
int i;
int j;
char line[255];
int *table;
int *x;
input = fopen ( input_filename, "r" );
if ( !input )
{
printf ( "\n" );
printf ( "I4MAT_DATA_READ - Fatal error!\n" );
printf ( " Could not open the input file: \"%s\"\n", input_filename );
return NULL;
}
table = ( int * ) malloc ( m * n * sizeof ( int ) );
x = ( int * ) malloc ( m * sizeof ( int ) );
j = 0;
while ( j < n )
{
got_string = fgets ( line, LINE_MAX, input );
if ( !got_string )
{
break;
}
if ( line[0] == '#' || s_len_trim ( line ) == 0 )
{
continue;
}
error = s_to_i4vec ( line, m, x );
if ( error == 1 )
{
continue;
}
for ( i = 0; i < m; i++ )
{
table[i+j*m] = x[i];
}
j = j + 1;
}
fclose ( input );
free ( x );
return table;
# undef LINE_MAX
}
int file_column_count ( char *input_filename )
/******************************************************************************/
/*
Purpose:
FILE_COLUMN_COUNT counts the number of columns in the first line of a file.
Discussion:
The file is assumed to be a simple text file.
Most lines of the file is presumed to consist of COLUMN_NUM words, separated
by spaces. There may also be some blank lines, and some comment lines,
which have a "#" in column 1.
The routine tries to find the first non-comment non-blank line and
counts the number of words in that line.
If all lines are blanks or comments, it goes back and tries to analyze
a comment line.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
13 June 2003
Author:
John Burkardt
Parameters:
Input, char *INPUT_FILENAME, the name of the file.
Output, int FILE_COLUMN_COUNT, the number of columns assumed
to be in the file.
*/
{
# define LINE_MAX 255
int column_num;
char *error;
FILE *input;
int got_one;
char line[LINE_MAX];
/*
Open the file.
*/
input = fopen ( input_filename, "r" );
if ( !input )
{
column_num = -1;
printf ( "\n" );
printf ( "FILE_COLUMN_COUNT - Fatal error!\n" );
printf ( " Could not open the input file: \"%s\"\n", input_filename );
return column_num;
}
/*
Read one line, but skip blank lines and comment lines.
*/
got_one = 0;
for ( ; ; )
{
error = fgets ( line, LINE_MAX, input );
if ( !error )
{
break;
}
if ( s_len_trim ( line ) == 0 )
{
continue;
}
if ( line[0] == '#' )
{
continue;
}
got_one = 1;
break;
}
if ( got_one == 0 )
{
fclose ( input );
input = fopen ( input_filename, "r" );
for ( ; ; )
{
error = fgets ( line, LINE_MAX, input );
if ( !error )
{
break;
}
if ( s_len_trim ( line ) == 0 )
{
continue;
}
got_one = 1;
break;
}
}
fclose ( input );
if ( got_one == 0 )
{
printf ( "\n" );
printf ( "FILE_COLUMN_COUNT - Warning!\n" );
printf ( " The file does not seem to contain any data.\n" );
return -1;
}
column_num = s_word_count ( line );
return column_num;
# undef LINE_MAX
}
double s_to_r8 ( char *s, int *lchar, int *error )
/******************************************************************************/
/*
Purpose:
S_TO_R8 reads an R8 value from a string.
Discussion:
We have had some trouble with input of the form 1.0E-312.
For now, let's assume anything less than 1.0E-20 is zero.
This routine will read as many characters as possible until it reaches
the end of the string, or encounters a character which cannot be
part of the real number.
Legal input is:
1 blanks,
2 '+' or '-' sign,
2.5 spaces
3 integer part,
4 decimal point,
5 fraction part,
6 'E' or 'e' or 'D' or 'd', exponent marker,
7 exponent sign,
8 exponent integer part,
9 exponent decimal point,
10 exponent fraction part,
11 blanks,
12 final comma or semicolon.
with most quantities optional.
Example:
S R
'1' 1.0
' 1 ' 1.0
'1A' 1.0
'12,34,56' 12.0
' 34 7' 34.0
'-1E2ABCD' -100.0
'-1X2ABCD' -1.0
' 2E-1' 0.2
'23.45' 23.45
'-4.2E+2' -420.0
'17d2' 1700.0
'-14e-2' -0.14
'e2' 100.0
'-12.73e-9.23' -12.73 * 10.0**(-9.23)
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
24 June 2005
Author:
John Burkardt
Parameters:
Input, char *S, the string containing the
data to be read. Reading will begin at position 1 and
terminate at the end of the string, or when no more
characters can be read to form a legal real. Blanks,
commas, or other nonnumeric data will, in particular,
cause the conversion to halt.
Output, int *LCHAR, the number of characters read from
the string to form the number, including any terminating
characters such as a trailing comma or blanks.
Output, int *ERROR, is TRUE (1) if an error occurred and FALSE (0)
otherwise.
Output, double S_TO_R8, the value that was read from the string.
*/
{
char c;
int ihave;
int isgn;
int iterm;
int jbot;
int jsgn;
int jtop;
int nchar;
int ndig;
double r;
double rbot;
double rexp;
double rtop;
char TAB = 9;
nchar = s_len_trim ( s );
*error = 0;
r = 0.0;
*lchar = -1;
isgn = 1;
rtop = 0.0;
rbot = 1.0;
jsgn = 1;
jtop = 0;
jbot = 1;
ihave = 1;
iterm = 0;
for ( ; ; )
{
c = s[*lchar+1];
*lchar = *lchar + 1;
/*
Blank or TAB character.
*/
if ( c == ' ' || c == TAB )
{
if ( ihave == 2 )
{
}
else if ( ihave == 6 || ihave == 7 )
{
iterm = 1;
}
else if ( 1 < ihave )
{
ihave = 11;
}
}
/*
Comma.
*/
else if ( c == ',' || c == ';' )
{
if ( ihave != 1 )
{
iterm = 1;
ihave = 12;
*lchar = *lchar + 1;
}
}
/*
Minus sign.
*/
else if ( c == '-' )
{
if ( ihave == 1 )
{
ihave = 2;
isgn = -1;
}
else if ( ihave == 6 )
{
ihave = 7;
jsgn = -1;
}
else
{
iterm = 1;
}
}
/*
Plus sign.
*/
else if ( c == '+' )
{
if ( ihave == 1 )
{
ihave = 2;
}
else if ( ihave == 6 )
{
ihave = 7;
}
else
{
iterm = 1;
}
}
/*
Decimal point.
*/
else if ( c == '.' )
{
if ( ihave < 4 )
{
ihave = 4;
}
else if ( 6 <= ihave && ihave <= 8 )
{
ihave = 9;
}
else
{
iterm = 1;
}
}
/*
Exponent marker.
*/
else if ( ch_eqi ( c, 'E' ) || ch_eqi ( c, 'D' ) )
{
if ( ihave < 6 )
{
ihave = 6;
}
else
{
iterm = 1;
}
}
/*
Digit.
*/
else if ( ihave < 11 && '0' <= c && c <= '9' )
{
if ( ihave <= 2 )
{
ihave = 3;
}
else if ( ihave == 4 )
{
ihave = 5;
}
else if ( ihave == 6 || ihave == 7 )
{
ihave = 8;
}
else if ( ihave == 9 )
{
ihave = 10;
}
ndig = ch_to_digit ( c );
if ( ihave == 3 )
{
rtop = 10.0 * rtop + ( double ) ndig;
}
else if ( ihave == 5 )
{
rtop = 10.0 * rtop + ( double ) ndig;
rbot = 10.0 * rbot;
}
else if ( ihave == 8 )
{
jtop = 10 * jtop + ndig;
}
else if ( ihave == 10 )
{
jtop = 10 * jtop + ndig;
jbot = 10 * jbot;
}
}
/*
Anything else is regarded as a terminator.
*/
else
{
iterm = 1;
}
/*
If we haven't seen a terminator, and we haven't examined the
entire string, go get the next character.
*/
if ( iterm == 1 || nchar <= *lchar + 1 )
{
break;
}
}
/*
If we haven't seen a terminator, and we have examined the
entire string, then we're done, and LCHAR is equal to NCHAR.
*/
if ( iterm != 1 && (*lchar) + 1 == nchar )
{
*lchar = nchar;
}
/*
Number seems to have terminated. Have we got a legal number?
Not if we terminated in states 1, 2, 6 or 7!
*/
if ( ihave == 1 || ihave == 2 || ihave == 6 || ihave == 7 )
{
*error = 1;
return r;
}
/*
Number seems OK. Form it.
We have had some trouble with input of the form 1.0E-312.
For now, let's assume anything less than 1.0E-20 is zero.
*/
if ( jtop == 0 )
{
rexp = 1.0;
}
else
{
if ( jbot == 1 )
{
if ( jsgn * jtop < -20 )
{
rexp = 0.0;
}
else
{
rexp = pow ( ( double ) 10.0, ( double ) ( jsgn * jtop ) );
}
}
else
{
if ( jsgn * jtop < -20 * jbot )
{
rexp = 0.0;
}
else
{
rexp = jsgn * jtop;
rexp = rexp / jbot;
rexp = pow ( ( double ) 10.0, ( double ) rexp );
}
}
}
r = isgn * rexp * rtop / rbot;
return r;
}
double s_to_r8 ( std::string s, int *lchar, bool *error )
{
char c;
int ihave;
int isgn;
int iterm;
int jbot;
int jsgn;
int jtop;
int nchar;
int ndig;
double r;
double rbot;
double rexp;
double rtop;
char TAB = 9;
nchar = s_len_trim ( s );
*error = false;
r = 0.0;
*lchar = -1;
isgn = 1;
rtop = 0.0;
rbot = 1.0;
jsgn = 1;
jtop = 0;
jbot = 1;
ihave = 1;
iterm = 0;
for ( ; ; )
{
c = s[*lchar+1];
*lchar = *lchar + 1;
//
// Blank or TAB character.
//
if ( c == ' ' || c == TAB )
{
if ( ihave == 2 )
{
}
else if ( ihave == 6 || ihave == 7 )
{
iterm = 1;
}
else if ( 1 < ihave )
{
ihave = 11;
}
}
//
// Comma.
//
else if ( c == ',' || c == ';' )
{
if ( ihave != 1 )
{
iterm = 1;
ihave = 12;
*lchar = *lchar + 1;
}
}
//
// Minus sign.
//
else if ( c == '-' )
{
if ( ihave == 1 )
{
ihave = 2;
isgn = -1;
}
else if ( ihave == 6 )
{
ihave = 7;
jsgn = -1;
}
else
{
iterm = 1;
}
}
//
// Plus sign.
//
else if ( c == '+' )
{
if ( ihave == 1 )
{
ihave = 2;
}
else if ( ihave == 6 )
{
ihave = 7;
}
else
{
iterm = 1;
}
}
//
// Decimal point.
//
else if ( c == '.' )
{
if ( ihave < 4 )
{
ihave = 4;
}
else if ( 6 <= ihave && ihave <= 8 )
{
ihave = 9;
}
else
{
iterm = 1;
}
}
//
// Exponent marker.
//
else if ( ch_eqi ( c, 'E' ) || ch_eqi ( c, 'D' ) )
{
if ( ihave < 6 )
{
ihave = 6;
}
else
{
iterm = 1;
}
}
//
// Digit.
//
else if ( ihave < 11 && '0' <= c && c <= '9' )
{
if ( ihave <= 2 )
{
ihave = 3;
}
else if ( ihave == 4 )
{
ihave = 5;
}
else if ( ihave == 6 || ihave == 7 )
{
ihave = 8;
}
else if ( ihave == 9 )
{
ihave = 10;
}
ndig = ch_to_digit ( c );
if ( ihave == 3 )
{
rtop = 10.0 * rtop + ( double ) ndig;
}
else if ( ihave == 5 )
{
rtop = 10.0 * rtop + ( double ) ndig;
rbot = 10.0 * rbot;
}
else if ( ihave == 8 )
{
jtop = 10 * jtop + ndig;
}
else if ( ihave == 10 )
{
jtop = 10 * jtop + ndig;
jbot = 10 * jbot;
}
}
//
// Anything else is regarded as a terminator.
//
else
{
iterm = 1;
}
//
// If we haven't seen a terminator, and we haven't examined the
// entire std::string, go get the next character.
//
if ( iterm == 1 || nchar <= *lchar + 1 )
{
break;
}
}
//
// If we haven't seen a terminator, and we have examined the
// entire std::string, then we're done, and LCHAR is equal to NCHAR.
//
if ( iterm != 1 && (*lchar) + 1 == nchar )
{
*lchar = nchar;
}
//
// Number seems to have terminated. Have we got a legal number?
// Not if we terminated in states 1, 2, 6 or 7!
//
if ( ihave == 1 || ihave == 2 || ihave == 6 || ihave == 7 )
{
*error = true;
return r;
}
//
// Number seems OK. Form it.
//
if ( jtop == 0 )
{
rexp = 1.0;
}
else
{
if ( jbot == 1 )
{
rexp = pow ( 10.0, jsgn * jtop );
}
else
{
rexp = jsgn * jtop;
rexp = rexp / jbot;
rexp = pow ( 10.0, rexp );
}
}
r = isgn * rexp * rtop / rbot;
return r;
}
