Direct answer export to text type formats

[roshan-g20]

My question is, is there any way to directly write the answer in a text file instead of the terminal shell, this app is great, but as I use it on termux it has Max 50000 rows any number larger than that can't be scrolled back, so I wanted this app to directly write the answer in a text file, question 2: can I set the precision of the output manually, like how many digits answers I get etc?

[lcn2]

My question is, is there any way to directly write the answer in a text file instead of the terminal shell, this app is great, but as I use it on termux it has Max 50000 rows any number larger than that can't be scrolled back, so I wanted this app to directly write the answer in a text file

Hello @roshan-g20.

Calc has a set of built-in functions that allow you to do file I/O. For general info on file I/O see:

; help file

FYI: The leading ";"'s in these interactive examples is just the interactive prompt of calc.

You may open, and create a new file or truncate an old file, as needed:

; outfile = fopen("/tmp/output", "w");

And then print values to that file:

; bigprime = 391581 * 2^216193 - 1
; fprintf(outfile, "%d is prime\n", bigprime)

The output of a large number may be subject to buffering, so you probably want to flush the output to be sure that your OS / libc streams are written to disk. So you may wish to follow the above fprintf call with :

; fflush(outfile)

Or even close the file:

; fclose(outfile)

For more info see:

; help fopen
; help fprintf
; help fflush
; help fclose

Write your own function to write values to a file

See discussion 6757645 for an overview on calc resource files and user defined functions.

You may use these to create your own "write to file" (or "w2f" for short system.

For example, put in a file called w2f.cal something along the lines of the following:

/* write numbers to a file */

static outfilename;  /* where to write stuff */
static outfile;      /* open file stream on which to write */
static stderr;       /* write errors to standard error */

/* setup */
if (!isstr(outfilename)) {
    outfilename = "./outfile";
}
if (!isfile(stderr)) {
    stderr = files(2);
    if (!isfile(stderr)) {
        printf("Warning: stderr as files(2) is not a file!\n");
    }
}

/* try to create or open and truncate the outfile */
if (!isfile(outfile)) {
    /* open outfilename for writing at the beginning */
    outfile = fopen(outfilename, "w");

    /* firewall - check for failing to open */
    if (!isfile(outfile)) {
        fprintf(stderr, "failed to open: %s error(%d): %s\n", outfilename, errno(outfile), strerror(outfile));
    }
}

/* write a value to a file given a format */
define w2f(filename, stream, fmt, value) {
    
    /* firewall */
    if (!isfile(stderr)) {
        printf("stderr is not an open file\n");
        return;
    }
    if (!isstr(filename)) {
        fprintf(stderr, "filename argument is not a string\n");
        return;
    }
    if (!isfile(stream)) {
        fprintf(stderr, "stream argument is not an open file\n");
        return;
    }
    if (!isstr(fmt)) {
        fprintf(stderr, "fmt argument is not a string\n");
        return;
    }
    if (!isnum(value)) {
        fprintf(stderr, "value argument is not a numeric value\n");
        return;
    }

    /* write value in decimal */
    fprintf(stream, fmt, value);
    if (ferror(stream)) {
        fprintf(stderr, "error in writing to file: %s error(%d): %s\n", filename, errno(stream), strerror(stream));
        return;
    }

    /* flush to be sure it is completely written */
    fflush(outfile);
    if (ferror(outfile)) {
        fprintf(stderr, "error in flushing to file: %s error(%d): %s\n", filename, errno(stream), strerror(stream));
    }
    return;
}

/* wd2f - write a value to an open file in decimal */
define wd2f(value) {
    return w2f(outfilename, outfile, "%d\n", value);
}

/* wx2f - write a value to an open file in hexadecimal */
define wx2f(value) {
    return w2f(outfilename, outfile, "%x\n", value);
}

Assuming we made no typos (we are entering this via an iPad and not testing the code, so parson typos), you can do:

; read w2f
; display(1000)
; epsilon(1e-1000)
; wd2f(pi())
; wd2f(sin(1))
; wd2f(2^23209-1)
; wx2f(exp(1, 1e-500))
; wx2f(log(3i))
; wx2f(2^21701-1)

Again, please pardon ant typos in the above calc resource file. It was typed in, as we were entering this comment, by hand via an iPad. Hopefully it will give you a general idea, even with typos. :-)

Converting large values to decimal

If a value a HUGE, computing the digits of a value in decimal can be TIME CONSUMING operation. Printing in octal (use "%o", hexadecimal (use %x") or binary (use %b) will be much faster than printing in base 10.

; fprintf(outfile, "the prime in hex is: %x\n", bigprime);

See:

; help printf

for details about format strings.

BTW: Printing non-integers in octal, hexadecimal or binary will print the internal faction of that value:

; printf("%x\n", pi())

A quick way to get the memory size of a number is to use:

; print memsize(bigprime)

If the value is an integer, you can get an idea of the numerical size in bits. by printing the high bit position of a value:

; print highbit(bigprime)

As mentioned above, computing the digits of a value in decimal can be TIME CONSUMING operation. This applies to the digits() function as well:

; print "calculating the number decimal digits of a big number can take a while:", digits(13^10000000);

calc I/O summary

Calc a lots of file I/O related functions. Most of them start with "f". For a complete list of built functions, see:

; help builtin

Every function has its own help file, so for example:

; help freopen

Many give you hints about related functions in the "SEE ALSO section":

SEE ALSO
    errno, fclose, feof, ferror, fflush, fgetc, fgetline, fgets, files, fopen,
    fprintf, fputc, fputs, fseek, fsize, ftell, isfile, printf, prompt

We hope this helps.

[lcn2]

For a list of call file related functions, see discussion comment 7180636

[lcn2]

question 2: can I set the precision of the output manually, like how many digits answers I get etc?

The display() builtin function controls how many decimal digits after the decimal point are printed.

; help display

FYI: The leading ";"'s in these interactive examples is just the interactive prompt of calc.

IMPORTANT NOTE: The precision (think accuracy below the decimal point) must also be considered. Simply extending the number of digits to display may not produce digits or more accurate digits.

The epsilon() builtin function controls precision of calculations performed. See:

; help epsilon

Many functions take an optional epsilon value. For example, the 2nd call to pi(1e-250) causes calc to calculate pi to an accuracy (an epsilon) of near 1e-250 (about 250 digits of accuracy):

; pi()
	3.14159265358979323846
; pi(1e-250)
	~3.14159265358979323846

NOTE the "~" indicating that the value printed is rounded while being printed. The usual default value of display() is 20 digits.

To get more digits displayed, try:

; display(250),

NOTE the use of the trailing comma. When a "," follows an expression, function, variable, etc, the value returned is not displayed. Normally display(250) would have returned the previous value of display() (which is likely was the default value of 20 digits).

Now print your pi with more precision:

; pi(1e-250)
	3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091

Again, to get more digits displayed after the decimal point, use the display() built-in to change the default of 20 digits after the decimal point.

Again, to get more accurate digits after the decimal point, calculate with a greater precision by setting beforehand, the global epsilon using the epsilon() built-in or by providing a given function (that takes such an optional argument), an epsilon argument. For example:

; sin(1, 1e-500)

Again, you need to keep in mind BOTH the number of digits displayed after the decimal point as well as the epsilon precision of calculations.

Of course, all the digits before the decimal point will always be printed, regardless of the value of display():

; 391581 * 2^216193-1

You may set certain things as a personal default a startup file according to the $CALCRC environment variable. See:

; help environment

Assuming that calc is started without -q, then calc will execute .calcinit from local directory, then execute ~/.calcrc from your home directory, then a startup file in the system directory (often /usr/local/share/calc/startup). So you can put your own set in that file. For example in our ~/.calcrc we like to put:

config("tilde_space",1),;
config("fraction_space",1),;
config("complex_space",1),;

And you could out, for example, this into your ~/.calcrc startup file:

config("display",80),;

The final ";" at the end of the line, terminates a command and separates it from other commands in the file.

Again, NOTE the use of the trailing comma ",". This trailing comma prevents calc from printing the return values of those functions.

FYI: display(80) is just an alias for config("display",80). You may use either form. By tradition we use config() to configure our calc sessions in our ~/.calcrc start up file.

See:

; help config

for info on what you can configure.

We hope this helps.