Script Programming(스크립트 프로그래밍)

#include <stdio.h>
#include <gsl/gsl_math.h>   // This includes <math.h>

int main(void) {
    double x, y, u, v;

    x = -0.9;
    y = asin(x);
    printf("x = %g\n", x);
    printf("y = asin(%g) = %.9f\n", x, y);
    printf("sin(%.9f) = %g\n", y, sin(y));
    printf("\n");

    x = 1.1;
    u = gsl_acosh(x);
    v = gsl_asinh(x);
    printf("x = %g\n", x);
    printf("u = gsl_acosh(%g) = %.10f\n", x, u);
    printf("v = gsl_asinh(%g) = %.10f\n", x, v);
    printf("\n");

    printf("cosh(u) = cosh(%.10f) = %g\n", u, cosh(u));
    printf("sinh(v) = sinh(%.10f) = %g\n", v, sinh(v));

    return 0;
}

/*
Output:
x = -0.9
y = asin(-0.9) = -1.119769515
sin(-1.119769515) = -0.9

x = 1.1
u = gsl_acosh(1.1) = 0.4435682544
v = gsl_asinh(1.1) = 0.9503469298

cosh(u) = cosh(0.4435682544) = 1.1
sinh(v) = sinh(0.9503469298) = 1.1

*/

#include <stdio.h>
#include <math.h>

double asinh(double x) {
    double y = log(x + sqrt(x*x + 1));
    return y;
}

double acosh(double x) {
    double y = log(x + sqrt(x*x - 1));
    return y;
}

int main() {

    double u, v;
    double x = -0.9;
    double y = asin(x);

    printf("y = asin(%g) = %.9f\n", x,  y);
    printf("sin(y) = sin(%.9f) = %g\n", y, sin(y));
    printf("\n");

    x = 1.1;
    u = acosh(x);
    printf("u = acosh(%g) = %.10f\n", x,  u);

    v = asinh(x);
    printf("v = asinh(%g) = %.10f\n", x, v);

    printf("cosh(u) = cosh(%.10f) = %g\n", u, cosh(u));
    printf("sinh(v) = sinh(%.10f) = %g\n", v, sinh(v));

    return 0;
}

/*
Output:
y = asin(-0.9) = -1.119769515
sin(y) = sin(-1.119769515) = -0.9

u = acosh(1.1) = 0.4435682544
v = asinh(1.1) = 0.9503469298
cosh(u) = cosh(0.4435682544) = 1.1
sinh(v) = sinh(0.9503469298) = 1.1
*/

// Filename: testLanczos-02.c
//
// Compile: gcc -o testLanczos-02 -lm testLanczos-02.c
// Execute: ./testLanczos-02
// Output:
//      Gamma(10) = (9)! = 362880
//     tgamma(10) = (9)! = 362880
//
// See: http://www.thinbasic.com/community/showthread.php?11279-Gamma-function
// See: http://en.wikipedia.org/wiki/Gamma_function
// See: http://http://jany.tistory.com/53
// See: http://support.realsoftware.com/listarchives/realbasic-nug/2003-08/msg03123.html

#include <stdio.h>
#include <math.h>

long double frac(long double x)
{
  long double result;

  if (x >= 0.0)
      result = fabs(x) - floor(x);
  else
      result = -(fabs(x) - floor(x));
  return result;
}

long double gamma2(long double y)
{
        long double pi = 3.1415926535897932385;
        long double sq2pi = 2.50662827463100050241577;  // sqrt(2Pi)
        long double g = 607./128;   // best resu'ts when 4<=g<=5
        long double t, w, gam, x = y - 1.0;
        int i, cg = 14;
        long double c[16];
        
        // Lanczos approximation for the complex plane
        // calculated using vpa digits(256)
        // the best set of coeffs was selected from
        // a solution space of g=0 to 32 with 1 to 32 terms
        // these coeffs really give superb performance
        // of 15 sig. digits for 0<=real(z)<=171
        // coeffs should sum to about g*g/2+23/24
        
        // http://www.numericana.com/answer/info/godfrey.htm
        
          c[ 1] =        0.99999999999999709182;   // thiBasic arrays start at 1 ?
          c[ 2] =       57.156235665862923517;
          c[ 3] =      -59.597960355475491248;
          c[ 4] =       14.136097974741747174;
          c[ 5] =       -0.49191381609762019978;
          c[ 6] =        0.33994649984811888699/10000;
          c[ 7] =        0.46523628927048575665/10000;
          c[ 8] =       -0.98374475304879564677/10000;
          c[ 9] =        0.15808870322491248884/1000;
          c[10] =       -0.21026444172410488319/1000;
          c[11] =        0.21743961811521264320/1000;
          c[12] =       -0.16431810653676389022/1000;
          c[13] =        0.84418223983852743293/10000;
          c[14] =       -0.26190838401581408670/10000;
          c[15] =        0.36899182659531622704/100000;
          
        // printf(" y = %LG\n", y);
       //  printf(" x = %LG\n", x);

        if ( x < 0.0 ) {
            x = -x;
            if (frac(x) == 0.0) {
                gam = pow(10.0, 4932);
            }
            else {
                t = c[1];
                for (i = 1; i <= cg; i++) {
                    t = t + c[i+1]/(x+i);
                }
                w = x + g + 0.5;
                gam = pow(w, x+0.5)*exp(-w)*sq2pi*t;
                gam = pi*x/(gam*sin(pi*x));
            }
        }
        else {
            t = c[1];
            for (i = 1; i <= cg; i++) {
                t = t + c[i+1]/(x+i);
            }
            w = x + g + 0.5;
            // printf("   w = %LG\n", w);
            gam = pow(w, x+0.5)*exp(-w)*sq2pi*t;
        }
        return gam;
 }

int main()
{
    long double y, x = 1.0;
    while (x > 0) {
        printf("Input x(0 to exit): ");
        scanf("%LF", &x);
        // printf("x = %LG\n", x);
        if (x == 0.0) {
            break;
        }
        y = gamma2(x);
        printf(" Gamma(%LG) = (%LG)! = %30LF\n", x, x - 1, y);
        printf("tgamma(%LG) = (%LG)! = %30lf\n", x, x - 1, tgamma(x));
    }
    // printf("All done. Press any key to finish\n");
    return 0;
}

/*
100! =  93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Execute: ./testLanczos-02
Result:
Input x(0 to exit): 101
 Gamma(101) = (100)! = 93326215443944119652178484825626229006662095017918287040779978859652504703806235528941436474245838774007726779438736471616107541007146050712395913562333118464.000000
tgamma(101) = (100)! = 93326215443947553183793338240612302366006877769275129529769934567734921397913148008797092443225880267680360266584467988186500321788890593731926090238149001216.000000
Input x(0 to exit): 0
*/

// Filename: testLongLong_001.c
//
// Compile & Link: gcc -o  testComplexISOC99_002  testLongLong_001.c
// Execute: ./tesLongLong_001
//
// Or
//
// Compile & Link: cl testLongLong_001.c
// Execute: testLongLong_001
//
// Or
//
// Compile & Link: lc testLongLong_001.c
// Execute: testLongLong_001
//
// Or
//
// Compile: lcc -o testLongLong_001.obj testLongLong_001.c
// Link: lcclnk testLongLong_001.obj
// Execute: tesLongLong_001

#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
 long long a = 1000000000L;
 long long b = 1000000000L;
 char buf[100];

    printf("a * b = %lld * %lld = %lld\n", a, b, a*b);

    sprintf(buf, "%lld", a*b);
    printf("strlen(a * b) = strlen(%lld) = %d\n", a*b, strlen(buf));

    return 0;
}

/*
-------------------
Result of execution:
-------------------
a * b = 1000000000 * 1000000000 = 1000000000000000000
strlen(a * b) = strlen(1000000000000000000) = 19
*/

// Filename: testComplexISOC99.c
//
// Compile & Link: gcc -o  testComplexISOC99  testComplexISOC99.c
// Execute: ./testComplexISOC99
//
// Or
//
// Compile & Link: lc testComplexISOC99.c
// Execute: testComplexISOC99
//
// Or
//
// Compile: lcc -o testComplexISOC99.obj testComplexISOC99.c
// Link: lcclnk testComplexISOC99.obj
// Execute: testComplexISOC99

#include <stdio.h>
#include <complex.h>

int main(int argc, char** argv)
{
 float complex z1 = 3.0 + 4.0i;
 float complex z2 = 2.0 - 1.0i;
 float complex z3 = z1 + z2;
 float complex z4 = z1 - z2;
 float complex z5 = z1 * z2;
 float complex z6 = z1 / z2;
 float complex z7 = conjf(z1);
 // float arg = cargf(z1);
 float arg = carg(z1);     // for :CC-win32

    printf("z1 = %f + %fj\n", crealf(z1), cimagf(z1));
    printf("z2 = %f + %fj\n", crealf(z2), cimagf(z2));
    printf("So,\n");
    printf("z3 = z1 + z2 = %f + %fj\n", crealf(z3), cimagf(z3));
    printf("z4 = z1 - z2 = %f + %fj\n", crealf(z4), cimagf(z4));
    printf("z5 = z1 * z2 = %f + %fj\n", crealf(z5), cimagf(z5));
    printf("z6 = z1 / z2 = %f + %fj\n", crealf(z6), cimagf(z6));

    printf("z7 = conjf(z1) = %f + %fj\n", crealf(z7), cimagf(z7));
    // printf("arg = cargf(z1) = %f\n", arg);
    printf("arg = carg(z1) = %f\n", arg);  // for LCC-win32

    return 0;
}

/*
-------------------
Result of execution:
-------------------
z1 = 3.000000 + 4.000000j
z2 = 2.000000 + 1.000000j
So,
z3 = z1 + z2 = 5.000000 + 5.000000j
z4 = z1 - z2 = 1.000000 + 3.000000j
z5 = z1 * z2 = 2.000000 + 11.000000j
z6 = z1 / z2 = 2.000000 + 1.000000j
z7 = conjf(z1) = 3.000000 + -4.000000j
arg = carg(z1) = 0.927295
*/

#include <stdio.h>
#include <gmp.h>

void factorial(mpz_t v, int n) {
 int i;
    mpz_t t;
    mpz_init (t);
    mpz_init_set_str (v, "1", 0);
    for (i = 1; i <= n; i++) {
        mpz_init_set_si (t, i);
        mpz_mul(v, v, t);
    }
}

int main(int argc, char *argv[]) {
    int n1 = 9;
    int n2 = 30;
    int i;
    mpz_t v;
    mpz_init (v);
    for (i = n1; i <= n2; i++) {
        mpz_init_set_si (v, 1);
        factorial(v, i);
        gmp_printf("%d! = %Zd\n", i, v);
        if (i == 13)
        printf("-- below calc are regular ----\n");
    }
    return 0;
}

#include <stdio.h>

long recFacto(long y, int k, int n) {
    if (n <= 1)
        return 1L;
    else if (k == n)
        return y;
    return recFacto(y*(k+1), k+1, n);
}

long factorial(int n) {
    return recFacto(1L, 1, n);
}

int main(int argc, char *argv[]) {
    int n = 20;
    int i;
    for (i = 0; i <= n; i++) {
        printf("%d! = %ld\n", i, factorial(i));
        if (i == 13)
         printf("-- below calc are fault ----\n");
    }
}

#include <stdio.h>
#include <string.h>
#include <math.h>

void printUsing();
void printMultTable(int x, int y);

int main(int argc, char *argv[]) {
    long x, y;
    if (argc >= 3) {
        x = atoi(argv[1]);
        y = atoi(argv[2]);
        printf("\n");
        printMultTable(x, y);
    }
    else {
        printUsing();
   }
    return 0;
}

void printUsing() {
    printf("Using: makeMultTable [number1] [number2]\n");
    printf("Print a multiplication table for the given two integers.\n");
}

void printMultTable(long x, long y) {
    long nx, ny;
    long z;
    int ntail1;
    int ntail2;
    int n;
    int y1;
    int i;
    char strX[80];
    char strY[80];
    char strZ[80];
    char strT[80];
    char zeros[80];
    char whites[80];
    char bars[80];
    char line1[80];
    char line2[80];
    char line3[80];
    char line4[80];
    char loffset[20];
    char buf[80];

    nx = (x >= 0) ? x : - x;
    ny = (y >= 0) ? y : - y;
    ntail1 = 0;
    ntail2 = 0;
    while (nx % 10L == 0L) {
        nx = nx / 10L;
        ntail1++;
    }
    while (ny % 10L == 0L) {
        ny = ny / 10L;
        ntail2++;
    }
    z = nx * ny;
    sprintf(strZ, "%ld", z);
    sprintf(strX, "%ld", nx);
    sprintf(strY, "%ld", ny);
    n = strlen(strY);
    strcpy(zeros, "0000000000000000000000000000000000000000");
    strcpy(whites, "                                        ");
    strcpy(bars, "----------------------------------------");
    strcpy(loffset, "       ");
    sprintf(line4, "%s%ld", loffset, nx*ny);
    strncpy(buf, zeros, ntail1 + ntail2);
    buf[ntail1 + ntail2] = '\0';
    strcat(line4, buf);
    strcpy(line1, loffset);
    strncpy(buf, whites, strlen(strZ) - strlen(strX));
    buf[strlen(strZ) - strlen(strX)] = '\0';
    strcat(buf, strX);
    strcat(line1, buf);
    strncpy(buf, zeros, ntail1);
    buf[ntail1] = '\0';
    strcat(line1, buf);

    strcpy(line2, "   x ) ");
    strncpy(buf, whites, strlen(strZ) - strlen(strY));
    buf[strlen(strZ) - strlen(strY)] = '\0';
    strcat(buf, strY);
    strcat(line2, buf);
    strncpy(buf, zeros, ntail2);
    buf[ntail2] = '\0';
    strcat(line2, buf);

    strcpy(line3, "     --");
    strncpy(buf, bars, strlen(strZ));
    buf[strlen(strZ)] = '\0';
    strcat(line3, buf);

    printf("%s\n", line1);
    printf("%s\n", line2);
    printf("%s\n", line3);
    if (strlen(strY) > 1) {
        for (i = 0; i < strlen(strY); i++) {
         buf[0] = strY[strlen(strY) - i - 1];
         buf[1] = '\0';
            y1 = atoi(buf);
            if (y1 != 0) {
                sprintf(strT, "%ld", nx * y1);
                strcpy(line2, loffset);
                strncpy(buf, whites, strlen(strZ) - strlen(strT) - i);
                buf[strlen(strZ) - strlen(strT) - i] = '\0';
                strcat(buf, strT);
                strcat(line2, buf);
                printf("%s\n", line2);
            }
        }
        printf("%s\n", line3);
    }
    printf("%s\n", line4);
}