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

/*
 * Filename: testLongLong0.c
 *
 * Compile: gcc -o testLongLong0 testLongLong0.c
 *   or
 * Compile: cl testLongLong0.c
 */

#include <stdio.h>

int main()
{
    printf("Maximum long long value is %40lld\n", 9223372036854775807LL);
    printf("Maximum long long value is %40llu\n", 9223372036854775807ULL);
    printf("Maximum long long value is %40lld\n", 9223372036854775808LL);
    printf("Maximum long long value is %40llu\n", 9223372036854775808ULL);

    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main()
{
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775807L);
    printf("       uint64 value is %40" PRIu64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
Maximum int64 value is                      9223372036854775807
Maximum int64 value is                         7fffffffffffffff
Maximum int64 value is                         7FFFFFFFFFFFFFFF
       uint64 value is                      9223372036854775807
Maximum int64 value is                     -9223372036854775808
Maximum int64 value is                         8000000000000000
Maximum int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |7fffffffffffffff                        |
Maximum int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

#include <stdio.h>
#include <stdio.h>
#include "inttypes.h"

int main()
{
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775807L);
    printf("       uint64 value is %40" PRIu64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
Maximum int64 value is                      9223372036854775807
Maximum int64 value is                         7fffffffffffffff
Maximum int64 value is                         7FFFFFFFFFFFFFFF
       uint64 value is                      9223372036854775807
Maximum int64 value is                     -9223372036854775808
Maximum int64 value is                         8000000000000000
Maximum int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |7fffffffffffffff                        |
Maximum int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

/*
 * Filename: testLongLong2.c
 *
 * Compile: gcc -o testLongLong2 testLongLong2.c
 *     or
 * Compile:cl testLongLong2.c
 *
 * See: http://en.wikipedia.org/wiki/Printf_format_string
 * See: http://msinttypes.googlecode.com/svn/trunk/inttypes.h
 * See: http://msinttypes.googlecode.com/svn/trunk/stdint.h
 * See: http://en.wikibooks.org/wiki/C_Programming/C_Reference/inttypes.h
 */

#include <stdio.h>
#include "stdint.h"      //  #include <inttypes.h>  for gcc or Visual C++ 2010
#include "inttypes.h"    //  #include <inttypes.h>  for gcc

int main()
{
    printf(" INT64_MAX = %30" PRId64 "\n", INT64_MAX);
    printf(" INT64_MAX = %30" PRIx64 "\n", INT64_MAX);
    printf("UINT64_MAX = %30" PRIu64 "\n", UINT64_MAX);
    printf("UINT64_MAX = %30" PRIx64 "\n", UINT64_MAX);
    printf("\n");

    printf("Maximum  int64 value is %40" PRId64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRIx64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRIX64 "\n", 9223372036854775807LL);
    printf("        uint64 value is %40" PRIu64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRId64 "\n", 9223372036854775808ULL);
    printf("Maximum  int64 value is %40" PRIx64 "\n", 9223372036854775808ULL);
    printf("Maximum  int64 value is %40" PRIX64 "\n", 9223372036854775808ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808ULL);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum  int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
 INT64_MAX =            9223372036854775807
 INT64_MAX =               7fffffffffffffff
UINT64_MAX =           18446744073709551615
UINT64_MAX =               ffffffffffffffff

Maximum  int64 value is                      9223372036854775807
Maximum  int64 value is                         7fffffffffffffff
Maximum  int64 value is                         7FFFFFFFFFFFFFFF
        uint64 value is                      9223372036854775807
Maximum  int64 value is                     -9223372036854775808
Maximum  int64 value is                         8000000000000000
Maximum  int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum  int64 value is |9223372036854775807                     |
Maximum  int64 value is |9223372036854775807                     |
Maximum  int64 value is |7fffffffffffffff                        |
Maximum  int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

/*
 * Filename: testGC_01.c 
 *
 *           Test a garbage collection for C language.
 *
 * Compile: gcc -o testGC_01 testGC_01.c -lgc
 *
 * Execute: ./testGC_01
 *
 * See: http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html
 */

#include "gc.h"
#include <assert.h>
#include <stdio.h>

int main()
{
    int i;

    GC_INIT(); /* Optional on Linux/X86; see below.  */
    for (i = 0; i < 10000000; ++i)
    {
        int **p = (int **) GC_MALLOC(sizeof(int *));
        int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));
        assert(*p == 0);
        *p = (int *) GC_REALLOC(q, 2 * sizeof(int));
        if (i % 100000 == 0)
            printf("Heap size = %d\n", GC_get_heap_size());
    }

    return 0;
}

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

#ifdef GC
#  include "gc.h"
#endif

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("Creating %d trees of depth %d\n", iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\tTop down construction took %d msec\n",
               elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\tBottom up construction took %d msec\n",
               elapsedTime(tFinish - tStart));

}

int main() {
        Node    root;
        Node    longLivedTree;
        Node    tempTree;
        long    tStart, tFinish;
        long    tElapsed;
   int i, d;
 double  *array;

#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes.\n\n",
               2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
               sizeof(double) * kArraySize);
        printf(" Stretching memory with a binary tree of depth %d\n",
               kStretchTreeDepth);
        PrintDiagnostics();
# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
       
        // Stretch the memory space quickly
        tempTree = MakeTree(kStretchTreeDepth);
# ifndef GC
          destroy_Node(tempTree);
# endif
        tempTree = 0;

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }
        PrintDiagnostics();

        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }

        if (longLivedTree == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
}

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
// Adapted to run NTHREADS client threads concurrently.  Each
// thread executes the original benchmark.  12 June 2000  by Hans Boehm.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>

#ifdef GC
#  ifndef LINUX_THREADS
#     define LINUX_THREADS
#  endif
#  ifndef _REENTRANT
#     define _REENTRANT
#  endif
#  ifdef LOCAL
#    define GC_REDIRECT_TO_LOCAL
#    include "gc_local_alloc.h"
#  endif
#  include "gc.h"
#endif

#ifndef NTHREADS
#   define NTHREADS 1
#endif

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("0x%x: Creating %d trees of depth %d\n", pthread_self(), iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Top down construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Bottom up construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));

}

void * run_one_test(void * arg) {
 int d;
        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }
}

int main() {
        Node    root;
        Node    longLivedTree;
        Node    tempTree;
        long    tStart, tFinish;
        long    tElapsed;
   int i;
 double  *array;

#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
#       if defined(GC) && defined(LOCAL)
   GC_thr_init();
#   endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes.\n\n",
               2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
               sizeof(double) * kArraySize);
        printf(" Stretching memory with a binary tree of depth %d\n",
               kStretchTreeDepth);
        PrintDiagnostics();
# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
       
        // Stretch the memory space quickly
        tempTree = MakeTree(kStretchTreeDepth);
# ifndef GC
          destroy_Node(tempTree);
# endif
        tempTree = 0;

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }

        {
   pthread_t thread[NTHREADS];
   for (i = 1; i < NTHREADS; ++i) {
         int code;

     if ((code = pthread_create(thread+i, 0, run_one_test, 0)) != 0) {
           fprintf(stderr, "Thread creation failed %u\n", code);
       exit(1);
     }
   }
   /* We use the main thread to run one test.  This allows */
   /* profiling to work, for example.    */
   run_one_test(0);
   for (i = 1; i < NTHREADS; ++i) {
         int code;
     if ((code = pthread_join(thread[i], 0)) != 0) {
         fprintf(stderr, "Thread join failed %u\n", code);
           }
    }
        }
        PrintDiagnostics();

        if (longLivedTree == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
}

// This is version 2 of the multithreaded GC Bench.
// Heap expansion is handled differently from version 1, in an attempt
// to make scalability measurements more meaningful.  The version with
// N threads now immediately expands the heap to N*32MB.
//
// To run this with BDWGC versions 6 and later with thread local allocation,
// define GC and LOCAL.  Without thread-local allocation, define just GC.
// To run it with the University of Tokyo scalable GC,
// define SGC.  To run it with malloc and explicit deallocation, define
// none of these.  (This should also work for Hoard.)
//
// Note that defining GC or SGC removes the explicit deallocation passes,
// which seems fair.
//
// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
// Adapted to run NTHREADS client threads concurrently.  Each
// thread executes the original benchmark.  12 June 2000  by Hans Boehm.
// Changed heap expansion rule, and made the number of threads run-time
// configurable.  25 Oct 2000 by Hans Boehm.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we were aware at the time.
//      It still doesn't seem too bad for something this small.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  This versions of the benchmark tries
//      to preallocate a sufficiently large heap that expansion should not be
//      needed.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.
//
//      Since this benchmark has recently been more widely used, some
//      anomalous behavious has been uncovered.  The user should be aware
//      of this:
//      1) Nearly all objects are of the same size.  This benchmark is
//         not useful for analyzing fragmentation behavior.  It is unclear
//         whether this is an issue for well-designed allocators.
//      2) Unless HOLES is defined, it tends to drop consecutively allocated
//         memory at the same time.  Many real applications do exhibit this
//         phenomenon, but probably not to this extent.  (Defining HOLES tends
//         to move the benchmark to the opposite extreme.)
//      3) It appears harder to predict object lifetimes than for most real
//         Java programs (see T. Harris, "Dynamic adptive pre-tenuring",
//         ISMM '00).

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>

#ifdef GC
#  ifndef LINUX_THREADS
#     define LINUX_THREADS
#  endif
#  ifndef _REENTRANT
#     define _REENTRANT
#  endif
#  ifdef LOCAL
#    define GC_REDIRECT_TO_LOCAL
#    include "gc_local_alloc.h"
#  endif
#  include "gc.h"
#endif
#ifdef SGC
#  include "sgc.h"
#  define GC
#  define pthread_create GC_pthread_create
#  define pthread_join GC_pthread_join
#endif

#define MAX_NTHREADS 1024

int nthreads = 0;

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("0x%x: Creating %d trees of depth %d\n", pthread_self(), iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Top down construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Bottom up construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));

}

void * run_one_test(void * arg) {
 int d, i;
        Node    longLivedTree;
 double  *array;
 /* size_t initial_bytes = GC_get_total_bytes(); */

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }

        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }
 /* printf("Allocated %ld bytes before start, %ld after\n",
  initial_bytes, GC_get_total_bytes() - initial_bytes); */
        if (longLivedTree->left -> right == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

}

int main(int argc, char **argv) {
        Node    root;
        Node    tempTree[MAX_NTHREADS];
        long    tStart, tFinish;
        long    tElapsed;
   int i;
# ifdef SGC
   SGC_attr_t attr;
# endif

 if (1 == argc) {
     nthreads = 1;
 } else if (2 == argc) {
     nthreads = atoi(argv[1]);
     if (nthreads < 1 || nthreads > MAX_NTHREADS) {
  fprintf(stderr, "Invalid # of threads argument\n");
  exit(1);
     }
 } else {
     fprintf(stderr, "Usage: %s [# of threads]\n");
     exit(1);
 }
#       if defined(SGC)
   /* The University of Tokyo collector needs explicit */
   /* initialization.     */
   SGC_attr_init(&attr);
   SGC_init(nthreads, &attr);
#   endif
#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes or less .\n\n",
               2 * sizeof(Node0) * nthreads
          * (TreeSize(kLongLivedTreeDepth) + TreeSize(kMaxTreeDepth))
               + sizeof(double) * kArraySize);
        PrintDiagnostics();
       
# ifdef GC
   /* GC_expand_hp fails with empty heap */
   GC_malloc(1);
   GC_expand_hp(32*1024*1024*nthreads);
# endif

# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
        {
   pthread_t thread[MAX_NTHREADS];
   for (i = 1; i < nthreads; ++i) {
         int code;

     if ((code = pthread_create(thread+i, 0, run_one_test, 0)) != 0) {
           fprintf(stderr, "Thread creation failed %u\n", code);
       exit(1);
     }
   }
   /* We use the main thread to run one test.  This allows */
   /* profiling to work, for example.    */
   run_one_test(0);
   for (i = 1; i < nthreads; ++i) {
         int code;
     if ((code = pthread_join(thread[i], 0)) != 0) {
         fprintf(stderr, "Thread join failed %u\n", code);
           }
    }
        }
        PrintDiagnostics();

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
        return 0;
}

// Filename: testHexView_02.c
//
//  Chapter 1.  Section 1.
//
//       A basic pattern of C++ Programing
//
// Compile: gcc -o testHexView_02 testHexView_02.c

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h> 

void toHex(char c, char a[3]);
void toHex8(int n, char a[10]);

int main(int argc, char *argv[])
{
    char *fname;
     FILE *file2;

    fpos_t fsize;
    long m;
    int i;

    char x;
    char s[3];
    char t[10];
    char buf[16];
    fpos_t n = 0L;

    struct stat stt;

    if (argc < 2)
    {
        printf("Usage: testHexView_02 [filename]\n");
        exit( 1 );
    }

    fname = argv[1];

    if (stat(fname, &stt) == 0 )
    {
        if ( stt.st_mode & S_IFDIR )
        {
            printf("\"%s\" is a directory\n", fname);
            exit( 1 );
        }
    }
   
    if (access(fname, R_OK) != 0)
    {
        printf("The file: \"%s\" is not readble.\n", fname);
        exit( 1 );
    }
 
    file2 = fopen(fname, "rb");

    if (!file2)
    {
        printf("Fail to open the file: \"%s\".\n", fname);
        exit( 1 );
    }

    s[2] = '\0';
    t[4] = ' ';
    t[9] = '\0';
    if (file2)
    {
        fseek(file2, 0, SEEK_END);    // seek to end of file
        fsize = ftell(file2);                 // get current file pointer

        printf("Its file size is %ld.\n\n", fsize);

        fseek(file2, 0, SEEK_SET);

        while(n < fsize && !feof(file2))
        {
            toHex8(n, t);
            printf("%s: ", t);
      
            fread(buf, sizeof(buf), 1, file2);
            m = (((fsize - n) < 16L) ? (long) (fsize - n) : 16L);
            for (i = 0; i < m; i++)
            {
                x = buf[i];
                toHex(x, s);
                printf("%s", s);
                if (i == 7)
                    printf("-");
                else
                    printf(" ");
            }
            if (m < 16)
            {
                for (i = 0; i < 16 - m; i++)
                {
                    printf("   ");
                }
            }

            printf("|");
            for (i = 0; i < m; i++)
            {
                if (buf[i] < ' ')
                    printf(".");
                else
                    printf("%c", buf[i]);
            }
            if (m < 16)
            {
                for (i = 0; i < 16 - m; i++)
                {
                    printf(" ");
                }
            }
            printf("|");

            n += m;
            printf("\n");
        }

        fclose(file2);
      
        printf("\n");;
        printf("Read %ld bytes.\n", n);
    }
    else {
        printf("Fail to read the file: \"%s\".,", fname);
    }
}

void toHex(char c, char a[3]) {
    int x1, x2;
    x1 = (c & 0xF0) >> 4;
    x2 = c & 0x0F;
    if (x1 < 10)
        a[0] = x1 + '0';
    else
        a[0] = (x1 - 10) + 'A';
    if (x2 < 10)
        a[1] = x2 + '0';
    else
        a[1] = (x2 - 10) + 'A';
}

void toHex8(int n, char a[10]) {
    int x1, x2, x3, x4, x5, x6, x7, x8;
    x1 = (n & 0xF0000000) >> 28;
    x2 = (n & 0xF000000) >> 24;
    x3 = (n & 0xF00000) >> 20;
    x4 = (n & 0xF0000) >> 16;
    x5 = (n & 0xF000) >> 12;
    x6 = (n & 0xF00) >> 8;
    x7 = (n & 0xF0) >> 4;
    x8 = n & 0x0F;
    if (x1 < 10)
        a[0] = x1 + '0';
    else
        a[0] = (x1 - 10) + 'A';
    if (x2 < 10)
        a[1] = x2 + '0';
    else
        a[1] = (x2 - 10) + 'A';
    if (x3 < 10)
        a[2] = x3 + '0';
    else
        a[2] = (x3 - 10) + 'A';
    if (x4 < 10)
        a[3] = x4 + '0';
    else
        a[3] = (x4 - 10) + 'A';
    a[4] = ' ';
    if (x5 < 10)
        a[5] = x5 + '0';
    else
        a[5] = (x5 - 10) + 'A';
    if (x6 < 10)
        a[6] = x6 + '0';
    else
        a[6] = (x6 - 10) + 'A';
    if (x7 < 10)
        a[7] = x7 + '0';
    else
        a[7] = (x7 - 10) + 'A';
    if (x8 < 10)
        a[8] = x8 + '0';
    else
        a[8] = (x8 - 10) + 'A';
}

/*
 * Copyright (c) 1993-1997, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 * Permission to use, copy, modify, and distribute this software for
 * any purpose and without fee is hereby granted, provided that the above
 * copyright notice appear in all copies and that both the copyright notice
 * and this permission notice appear in supporting documentation, and that
 * the name of Silicon Graphics, Inc. not be used in advertising
 * or publicity pertaining to distribution of the software without specific,
 * written prior permission.
 *
 * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
 * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
 * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
 * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
 * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
 * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
 * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
 * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * US Government Users Restricted Rights
 * Use, duplication, or disclosure by the Government is subject to
 * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
 * (c)(1)(ii) of the Rights in Technical Data and Computer Software
 * clause at DFARS 252.227-7013 and/or in similar or successor
 * clauses in the FAR or the DOD or NASA FAR Supplement.
 * Unpublished-- rights reserved under the copyright laws of the
 * United States.  Contractor/manufacturer is Silicon Graphics,
 * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
 *
 * OpenGL(R) is a registered trademark of Silicon Graphics, Inc.
 */

/*
 *  teapots.c
 *  This program demonstrates lots of material properties.
 *  A single light source illuminates the objects.
 */
#include <stdlib.h>
#include <GL/glut.h>

GLuint teapotList;

/*
 * Initialize depth buffer, projection matrix, light source, and lighting
 * model.  Do not specify a material property here.
 */
void init(void)
{
   GLfloat ambient[] = {0.0, 0.0, 0.0, 1.0};
   GLfloat diffuse[] = {1.0, 1.0, 1.0, 1.0};
   GLfloat specular[] = {1.0, 1.0, 1.0, 1.0};
   GLfloat position[] = {0.0, 3.0, 3.0, 0.0};

   GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0};
   GLfloat local_view[] = {0.0};

   glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
   glLightfv(GL_LIGHT0, GL_POSITION, position);
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
   glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

   glFrontFace(GL_CW);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_AUTO_NORMAL);
   glEnable(GL_NORMALIZE);
   glEnable(GL_DEPTH_TEST);
/*  be efficient--make teapot display list  */
   teapotList = glGenLists(1);
   glNewList (teapotList, GL_COMPILE);
   glutSolidTeapot(1.0);
   glEndList ();
}

/*
 * Move object into position.  Use 3rd through 12th
 * parameters to specify the material property.  Draw a teapot.
 */
void renderTeapot(GLfloat x, GLfloat y,
   GLfloat ambr, GLfloat ambg, GLfloat ambb,
   GLfloat difr, GLfloat difg, GLfloat difb,
   GLfloat specr, GLfloat specg, GLfloat specb, GLfloat shine)
{
   GLfloat mat[4];

   glPushMatrix();
   glTranslatef(x, y, 0.0);
   mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0;
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
   mat[0] = difr; mat[1] = difg; mat[2] = difb;
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat);
   mat[0] = specr; mat[1] = specg; mat[2] = specb;
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat);
   glMaterialf(GL_FRONT, GL_SHININESS, shine * 128.0);
   glCallList(teapotList);
   glPopMatrix();
}

/**
 *  First column:  emerald, jade, obsidian, pearl, ruby, turquoise
 *  2nd column:  brass, bronze, chrome, copper, gold, silver
 *  3rd column:  black, cyan, green, red, white, yellow plastic
 *  4th column:  black, cyan, green, red, white, yellow rubber
 */
void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   renderTeapot(2.0, 17.0, 0.0215, 0.1745, 0.0215,
      0.07568, 0.61424, 0.07568, 0.633, 0.727811, 0.633, 0.6);
   renderTeapot(2.0, 14.0, 0.135, 0.2225, 0.1575,
      0.54, 0.89, 0.63, 0.316228, 0.316228, 0.316228, 0.1);
   renderTeapot(2.0, 11.0, 0.05375, 0.05, 0.06625,
      0.18275, 0.17, 0.22525, 0.332741, 0.328634, 0.346435, 0.3);
   renderTeapot(2.0, 8.0, 0.25, 0.20725, 0.20725,
      1, 0.829, 0.829, 0.296648, 0.296648, 0.296648, 0.088);
   renderTeapot(2.0, 5.0, 0.1745, 0.01175, 0.01175,
      0.61424, 0.04136, 0.04136, 0.727811, 0.626959, 0.626959, 0.6);
   renderTeapot(2.0, 2.0, 0.1, 0.18725, 0.1745,
      0.396, 0.74151, 0.69102, 0.297254, 0.30829, 0.306678, 0.1);
   renderTeapot(6.0, 17.0, 0.329412, 0.223529, 0.027451,
      0.780392, 0.568627, 0.113725, 0.992157, 0.941176, 0.807843,
      0.21794872);
   renderTeapot(6.0, 14.0, 0.2125, 0.1275, 0.054,
      0.714, 0.4284, 0.18144, 0.393548, 0.271906, 0.166721, 0.2);
   renderTeapot(6.0, 11.0, 0.25, 0.25, 0.25,
      0.4, 0.4, 0.4, 0.774597, 0.774597, 0.774597, 0.6);
   renderTeapot(6.0, 8.0, 0.19125, 0.0735, 0.0225,
      0.7038, 0.27048, 0.0828, 0.256777, 0.137622, 0.086014, 0.1);
   renderTeapot(6.0, 5.0, 0.24725, 0.1995, 0.0745,
      0.75164, 0.60648, 0.22648, 0.628281, 0.555802, 0.366065, 0.4);
   renderTeapot(6.0, 2.0, 0.19225, 0.19225, 0.19225,
      0.50754, 0.50754, 0.50754, 0.508273, 0.508273, 0.508273, 0.4);
   renderTeapot(10.0, 17.0, 0.0, 0.0, 0.0, 0.01, 0.01, 0.01,
      0.50, 0.50, 0.50, .25);
   renderTeapot(10.0, 14.0, 0.0, 0.1, 0.06, 0.0, 0.50980392, 0.50980392,
      0.50196078, 0.50196078, 0.50196078, .25);
   renderTeapot(10.0, 11.0, 0.0, 0.0, 0.0,
      0.1, 0.35, 0.1, 0.45, 0.55, 0.45, .25);
   renderTeapot(10.0, 8.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0,
      0.7, 0.6, 0.6, .25);
   renderTeapot(10.0, 5.0, 0.0, 0.0, 0.0, 0.55, 0.55, 0.55,
      0.70, 0.70, 0.70, .25);
   renderTeapot(10.0, 2.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0,
      0.60, 0.60, 0.50, .25);
   renderTeapot(14.0, 17.0, 0.02, 0.02, 0.02, 0.01, 0.01, 0.01,
      0.4, 0.4, 0.4, .078125);
   renderTeapot(14.0, 14.0, 0.0, 0.05, 0.05, 0.4, 0.5, 0.5,
      0.04, 0.7, 0.7, .078125);
   renderTeapot(14.0, 11.0, 0.0, 0.05, 0.0, 0.4, 0.5, 0.4,
      0.04, 0.7, 0.04, .078125);
   renderTeapot(14.0, 8.0, 0.05, 0.0, 0.0, 0.5, 0.4, 0.4,
      0.7, 0.04, 0.04, .078125);
   renderTeapot(14.0, 5.0, 0.05, 0.05, 0.05, 0.5, 0.5, 0.5,
      0.7, 0.7, 0.7, .078125);
   renderTeapot(14.0, 2.0, 0.05, 0.05, 0.0, 0.5, 0.5, 0.4,
      0.7, 0.7, 0.04, .078125);
   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   if (w <= h)
      glOrtho(0.0, 16.0, 0.0, 16.0*(GLfloat)h/(GLfloat)w,
              -10.0, 10.0);
   else
      glOrtho(0.0, 16.0*(GLfloat)w/(GLfloat)h, 0.0, 16.0,
              -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

/*
 * Main Loop
 */
int main(int argc, char **argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(500, 600);
   glutInitWindowPosition(50,50);
   glutCreateWindow(argv[0]);
   init();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutKeyboardFunc (keyboard);
   glutMainLoop();
   return 0;
}

// Filename: cube.c
//
// See: http://www.glprogramming.com/red/chapter03.html

// #include <GL/gl.h>    // Commented out for Visual C
// #include <GL/glu.h>   // Commented out for Visual C
#include <GL/glut.h>

void init(void)
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}

void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 2.0, 1.0);      /* modeling transformation */
   glutWireCube (1.0);
   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500);
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutMainLoop();
   return 0;
}

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

int nbits(int n)
{
    int i = 0;
    while (n > 0) {
        n >>= 1;
        i++;
    }
    return i;
}

double bits(int n)
{
    return (int) (log((double)n)/log(2.0)) + 1;
}

int main()
{
    int i;
    int k1, k2;
   
    for (i = 1; i <= 65537; i++)
    {
     k1 = nbits(i);
     k2 = bits(i);
     if (k1 != k2) {
            printf("%7d:   k1 = nbits(%5d) = %2d", i, i, k1);
            printf(",   k2 = lg(%5d) + 1 = %2d\n", i, k2);
        }
    }
   
    return 0;
}

/*
Output with G++ on Cygwin
      8:  k1 = nbits(    8) =  4,   k2 = lg(    8) + 1 =  3
     64:  k1 = nbits(   64) =  7,   k2 = lg(   64) + 1 =  6
    128:  k1 = nbits(  128) =  8,   k2 = lg(  128) + 1 =  7
   4096:  k1 = nbits( 4096) = 13,   k2 = lg( 4096) + 1 = 12
   8192:  k1 = nbits( 8192) = 14,   k2 = lg( 8192) + 1 = 13
  16384:  k1 = nbits(16384) = 15,   k2 = lg(16384) + 1 = 14
  32768:  k1 = nbits(32768) = 16,   k2 = lg(32768) + 1 = 15
*/

/*
Output with Visual C++ 10 on Windows XP:
*/

// Filename: calcLG64.cpp
//
//        1) Calculate the number of bits of binary format of a given positive integer,
//        2) Compare it with lg(n) + 1 = log(n)/log(2) + 1
//
//   Compiling with Visual C++ 10.
//   Compile: cl /EHsc calcLG64.cpp
//   Execute: calcLG64
//
//     Or
//
//   Compiling with G++ on Cygwin.
//   Compile: g++ -o calcLG64 calcLG64.cpp
//   Execute: ./calcLG64
//
//   Date: 2013. 2. 23.
//  Author: pkim __AT__ scripts ((DOT)) pe ((DOT)) kr

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

#include <iomanip>
using std::setw;
 

int nbits(int n)
{
 int i = 0;
 while (n > 0) {
  n >>= 1;
  i++;
 }
 return i;
}

double bits(int n)
{
 return (int) (log((double)n)/log(2.0)) + 1;
}

int main()
{
    int i;
    int k1, k2;
   
    for (i = 1; i <= 65537; i++)
    {
     k1 = nbits(i);
     k2 = bits(i);
     if (k1 != k2) {
            cout << setw( 7 ) << i << ":  k1 = nbits(" << setw( 5 ) << i << ") = " << setw( 2 ) << k1;
            cout << ",   k2 = lg(" << setw( 5 ) << i << ") + 1 = " << setw( 2 ) << k2 << endl;
        }
    }
}

/*
Output with G++ on Cygwin
      8:  k1 = nbits(    8) =  4,   k2 = lg(    8) + 1 =  3
     64:  k1 = nbits(   64) =  7,   k2 = lg(   64) + 1 =  6
    128:  k1 = nbits(  128) =  8,   k2 = lg(  128) + 1 =  7
   4096:  k1 = nbits( 4096) = 13,   k2 = lg( 4096) + 1 = 12
   8192:  k1 = nbits( 8192) = 14,   k2 = lg( 8192) + 1 = 13
  16384:  k1 = nbits(16384) = 15,   k2 = lg(16384) + 1 = 14
  32768:  k1 = nbits(32768) = 16,   k2 = lg(32768) + 1 = 15
*/

/*
Output with Visual C++ 10 on Windows XP:
*/

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
// #include <amp_math.h>   // for log2()
                           // supported in Visual Studio 2012
                           // See: http://msdn.microsoft.com/en-us/library/hh308239.aspx
                          
int main( int argc, char *argv[] )
{
  double log_base_2 = 0;
  double given_value;

  if( argc < 2 )
  {
    fprintf( stderr, "ERROR! You must give a numeric argument!\n" );
    return 1;
  }

  given_value = strtod( argv[1], NULL );

  log_base_2 = log2( given_value );
  printf( "Log base 2 of %f is %f\n",
  //printf( "Log base 2 of %f is %.15f\n",
          given_value,
          log_base_2 );

  printf( "Floor of log base 2 of %f is %f\n",
          given_value,
          floor(log_base_2) );

  return 0;
}

/*
Compile and Execute:
$ gcc -o test_log2 test_log2.c
$ ./test_log2 8
Log base 2 of 8.000000 is 3.000000
Floor of log base 2 of 8.000000 is 3.000000

Compile and Execute:
$ gcc -o test_log2 test_log2.c -std=c99 -lm
$ ./test_log2 8
Log base 2 of 8.000000 is 3.000000
Floor of log base 2 of 8.000000 is 2.000000
*/

#include <stdio.h>

#define REPEAT 53

double f(double x)
{
    return 2.0*x*x - 1.0;
}

int main()
{
    double x = 0.7;
    double y, t;
    int i;

    printf("x = %g\n", x);
    printf("x = %f\n", x);
    printf("x = %.15f\n", x);
    printf("x = %.16f\n", x);
    printf("x = %.20f\n", x);
    printf("\n");

    printf("f is a function defined by f(x) = 2*x*x - 1\n");
    printf("f^(n) (x) means the n times composite of the function f(x),\n");
    printf("say, f^(2) (x) = f(f(x)), f^(2) (x) = f(f(f(x))), and etc\n");
    printf("\n");

    t = x;
    for (i = 1; i <= REPEAT; i++) {
        y = f(t);
        t = y;
    }

    printf("y = f^(53) (x) = f^(53) (%g) = %g\n", x, y);
    printf("y = f^(53) (x) = f^(53) (%g) = %f\n", x, y);
    printf("y = f^(53) (x) = f^(53) (%g) = %.15f\n", x, y);
    printf("y = f^(53) (x) = f^(53) (%g) = %.16f\n", x, y);
    printf("y = f^(53) (x) = f^(53) (%g) = %.20f\n", x, y);
    printf("Is it true?\n");
    printf("\n");

    printf("Its error is too big.\nThe iterated value shoul be -0.5671977142553364749...\n");
    printf("\n");

    return 0;
}

/*
Output:
x = 0.7
x = 0.700000
x = 0.700000000000000
x = 0.7000000000000000
x = 0.69999999999999996000

f is a function defined by f(x) = 2*x*x - 1
f^(n) (x) means the n times composite of the function f(x),
say, f^(2) (x) = f(f(x)), f^(2) (x) = f(f(f(x))), and etc

y = f^(53) (x) = f^(53) (0.7) = 0.538614
y = f^(53) (x) = f^(53) (0.7) = 0.538614
y = f^(53) (x) = f^(53) (0.7) = 0.538614158130321
y = f^(53) (x) = f^(53) (0.7) = 0.5386141581303205
y = f^(53) (x) = f^(53) (0.7) = 0.53861415813032054000
Is it true?

Its error is too big.
The iterated value shoul be -0.5671977142553364749...
*/

#include <stdio.h>

#define TEN    10
#define NINE   9
#define EIGHT   8

// initial calling: pyra1(1, 1)
void pyra1(int n, int i)
{
    if (i <= NINE) {
        printf("%9d x %d + %d = %d\n", n, EIGHT, i, n*EIGHT + i);
        if (i < NINE) {
            pyra1(n*TEN + (i + 1), i + 1);
        }
    }
}

// initial calling: pyra2(9, 7)
void pyra2(int n, int i)
{
    if (i >= 0) {
        printf("%8d x %d + %d = %d\n", n, NINE, i, n*NINE + i);
        if (i > 0) {
            pyra2(n*TEN + (i + 1), i - 1);
        }
    }
}

// initial calling: pyra3(1, 2)
void pyra3(int n, int i)
{
    if (i <= TEN) {
        printf("%9d x %d + %2d = %d\n", n, NINE, i, n*NINE + i);
        if (i < TEN) {
            pyra3(n*TEN + i, i + 1);
        }
    }
}

void pyramid1()
{
    int i, n;
    char s[TEN];

    for (i = 1; i < TEN; i++) {
        s[i - 1] = (char) (48 + i);
        s[i] = '\0';
        sscanf(s, "%d", &n);
        printf("%9d x %d + %d = %d\n", n, EIGHT, i, n*EIGHT + i);
    }
}

void pyramid2()
{
    int i, n;
    char s[TEN];

    for (i = NINE; i > 1; i--) {
        s[NINE - i] = (char) (48 + i);
        s[NINE - i + 1] = '\0';
        sscanf(s, "%d", &n);
        printf("%8d x %d + %d = %d\n", n, NINE, i - 2, n*NINE + (i - 2));
    }
}

void pyramid3()
{
    int i, n;
    char s[TEN];

    for (i = 1; i < TEN; i++) {
        s[i - 1] = (char) (48 + i);
        s[i] = '\0';
        sscanf(s, "%d", &n);
        printf("%9d x %d + %2d = %d\n", n, NINE, i + 1, n*NINE + (i + 1));
    }
}

int main()
{
    printf("Use for loops\n");
    printf("Pyramid 1\n");
    pyramid1();
    printf("\n");

    printf("Pyramid 2\n");
    pyramid2();
    printf("\n");

    printf("Pyramid 3\n");
    pyramid3();
    printf("\n");

    printf("Use recursively called functions\n");
    printf("Pyramid 1\n");
    pyra1(1, 1);
    printf("\n");

    printf("Pyramid 2\n");
    pyra2(9, 7);
    printf("\n");

    printf("Pyramid 3\n");
    pyra3(1, 2);
    printf("\n");

    return 0;
}

// Filename: testNthRoot.c
//
//            Approximate square roots, cubic roots and n-th roots of a given number.
//
// Compile: cl testNthRoot.c
// Execute: testNthRoot
//
// Date: 2013. 1. 6.
// Copyright (c) 2013 PH Kim  (pkim __AT__ scripts.pe.kr)

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

jmp_buf g_stkBuf;

#define NO_EXCEPTION          (0)
#define CANNOT_EVALUATE    (100)

#define MAX_ITER 20000
#define M_EPSILON 1.0e-15

/**
  * Compute the n-th root of x to a given scale, x > 0.
  */
double nPow(double a, int n)
{
    int i;
    double y;

    if (n > 0) {
        if (n == 1)
            return a;
        else {
            if (a == 0.0 || a == 1.0) {
                return a;
            }
            else if (a == -1.0) {
                if (n % 2 == 1)
                    return -1.0;
                else
                    return 1.0;
            }
            else if (a < 0.0) {
                if (n % 2 == 1)
                    return -nPow(-a, n);
                else
                    return nPow(-a, n);
            }
            else {
                y = 1.0;
                for (i = 0; i < n; i++) {
                    y *= a;
                }
                return y;
            }
        }
    }
    else if (n == 0) {
        return 1.0;
    }
    else {      //  when n < 0
        if (a == 0.0) {
            printf("Negative powering exception of zero.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        else {
            if (n == -1)
                return 1.0/a;
            else
                return 1.0/nPow(a, -n);
        }
    }
}

/**
  * Compute the n-th root of x to a given scale, x > 0.
  */
double gPow(double a, int n)
{
    int i;
    double y;
    double r;
    int m;
    int one;

    if (n > 0) {
        if (n == 1)
            return a;
        else {
            if (a == 0.0 || a == 1.0) {
                return a;
            }
            else if (a == -1.0) {
                if (n % 2 == 1)
                    return -1.0;
                else
                    return 1.0;
            }
            else if (a < 0.0) {
                if (n % 2 == 1)
                    return -gPow(-a, n);
                else
                    return gPow(-a, n);
            }
            else {

                y = 1.0;
                r = a;
                m = 8*sizeof(int) - 1;    // 8*sizeof(int) - 1;  ignore sign bit, which is MSB
                one = 1;
                for (i = 0; i < m; i++) {
                    if ((n & one) == 0) {
                        y *= 1.0;
                    }
                    else {
                        y *= r;
                    }
                    r = r*r;
                    one <<= 1;
                    if (one > n)
                        break;
                }
                return y;
            }
        }
    }
    else if (n == 0) {
        return 1.0;
    }
    else {      //  when n < 0
        if (a == 0.0) {
            printf("Negative powering exception of zero.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        else {
            if (n == -1)
                return 1.0/a;
            else
                return 1.0/gPow(a, -n);
        }
    }
}

/**
  * Compute the n-th root of x to a given scale, x > 0.
  */
double mPow(double a, int n)
{
    if (n > 0) {
        if (n == 1)
            return a;
        else {
            if (a == 0.0 || a == 1.0) {
                return a;
            }
            else if (a == -1.0) {
                if (n % 2 == 1)
                    return -1.0;
                else
                    return 1.0;
            }
            else if (a < 0.0) {
                if (n % 2 == 1)
                    return -mPow(-a, n);
                else
                    return mPow(-a, n);
            }
            else {

                double y = 1.0;
                double r = a;
                int m = n;
                while (m > 0) {
                    if ((m & 0x1) != 0) {
                        y *= r;
                    }
                    r = r*r;
                    m >>= 1;
                }
                return y;
            }
         }
    }
    else if (n == 0) {
        return 1.0;
    }
    else {      //  when n < 0
        if (a == 0.0) {
            printf("Negative powering exception of zero.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        else {
            if (n == -1)
                return 1.0/a;
            else
                return 1.0/mPow(a, -n);
        }
    }
}

/**
  * Compute the square root of x to a given scale, x > 0.
  */
double heronSqrt(double a)
{
    double x1, x2, er;
    int counter;

    if (a < 0.0) {
        printf("Cannot find the sqrt of a negative number.\n");
        longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
                                                 // errNo는 setjmp로 설정한 지점으로 복귀할 때 리턴 값
        return -1.0;
    }
    else if (a == 0.0 || a == 1.0) {
        return a;
    }
    else {
        x1 = a;
        x2 = (x1 + a/x1)/2.0;
        er = x1 - x2;
        counter = 0;
        while (x1 + er != x1) {
            x1 = x2;
            x2 = (x1 + a/x1)/2.0;
            er = x1 - x2;
            if (fabs(er) < fabs(M_EPSILON*x1))
                break;
            counter++;
            if (counter > MAX_ITER)
                break;
        }
        if (counter >= MAX_ITER) {
            printf("Inaccurate sqrt exception by too many iterations.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        return x2;
    }
}

/**
  * Compute the cubic root of x to a given scale, x > 0.
  */
double newtonCbrt(double a)
{
    double x1, x2, er;
    int counter;

    if (a == 0.0 || a == 1.0 || a == -1.0) {
        return a;
    }
    else if (a < 0.0) {
        return -newtonCbrt(-a);
    }
    else {
        x1 = a;
        x2 = (2.0*x1 + a/(x1*x1))/3.0;
        er = x1 - x2;
        counter = 0;
        while (x1 + er != x1) {
            x1 = x2;
            x2 = (2.0*x1 + a/(x1*x1))/3.0;
            er = x1 - x2;
            if (fabs(er) < fabs(M_EPSILON*x1))
                break;
            counter++;
            if (counter > MAX_ITER)
                break;
        }
        if (counter >= MAX_ITER) {
            printf("Inaccurate cbrt exception by too many iterations.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        return x2;
    }
}

/**
  * Compute the n-th root of x to a given scale, x > 0.
  */
double newtonNthRoot(int n, double a)
{
    double x1, x2, xn, er;
    int counter;

    if (n == 0) {
        return 1.0;
    }
    else if (n == 1) {
        return a;
    }
    else if (n > 0) {
        if (a == 0.0 || a == 1.0) {
            return a;
        }
        else if (a == -1.0) {
            if (n % 2 == 1)
                return a;
            else {
                printf("Cannot find the even n-th root of a negative number.\n");
                longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
                return -1.0;
            }
        }
        else if (a < 0.0) {
            if (n % 2 == 1)
                return -newtonNthRoot(n, -a);
            else {
                printf("Cannot find the even n-th root of a negative number.\n");
                longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
                return -1.0;
            }
        }
        else if (a < 1.0) {
            return 1.0/newtonNthRoot(n, 1.0/a);
        }
        else {
            x1 = a;
            xn = mPow(x1, n - 1);
            x2 = ((n - 1)*x1 + a/xn)/n;
            er = x1 - x2;
            counter = 0;
            while (x1 + er != x1) {
                x1 = x2;
                xn = mPow(x1, n - 1);
                x2 = ((n - 1)*x1 + a/xn)/n;
                er = x1 - x2;
                if (fabs(er) < fabs(M_EPSILON*x1))
                    break;
                counter++;
                if (counter > MAX_ITER)
                    break;
            }
            if (counter >= MAX_ITER) {
                printf("Inaccurate n-th exception by too many iterations.\n");
                longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
                return -1.0;
            }
            return x2;
        }
    }
    else {
        if (a == 0.0) {
            printf("Cannot find the negative n-th root of zero.\n");
            longjmp( g_stkBuf, CANNOT_EVALUATE );  // setjmp로 설정한 g_stkBuf(스택정보)를 가지고 해당 시점으로 복귀
            return -1.0;
        }
        else {
            return 1.0/newtonNthRoot(-n, a);
        }
    }
}

int main()
{
    double x = 16.0;
    double u = sqrt(x);

    int k;
    double t1, t2, t3;
    double y, z, w;

    int errNo = NO_EXCEPTION;

    printf("[ Testing heronSqrt(double) ]--------------------\n");
    printf("x = %g\n", x);
    printf("u = sqrt(%g) = %g\n", x, u);
    y = heronSqrt(x);
    printf("y = heronSqrt(%g) = %g\n", x, y);
    printf("y*y = %g\n", y*y);
    printf("\n");

    printf("[ Testing newtonCbrt(double) ]--------------------\n");
    x = -216.0;
    printf("x = %g\n", x);
    printf("-exp(log(-x)/3.0) = %g\n", -exp(log(-x)/3.0));
    w = newtonCbrt(x);
    printf("w = newtonCbrt(%g) = %g\n", x, w);
    printf("w*w*w = %g\n", w*w*w);
    printf("\n");

    x = 729000000000.0;
    printf("x = %g\n", x);
    printf("exp(log(x)/3.0) = %g\n", exp(log(x)/3.0));
    w = newtonCbrt(x);
    printf("w = newtonCbrt(%g) = %g\n", x, w);
    printf("w*w*w = %g\n", w*w*w);
    printf("\n");

    printf("[ Testing newtonNthRoot(int, double) ]--------------------\n");
    z = newtonNthRoot(3, x);
    printf("x = %g\n", x);
    printf("z = newtonNthRoot(3, %g) = %g\n", x, z);
    printf("z*z*z = %g\n", z*z*z);
    printf("\n");

    x = 12960000000000000000.0;
    z = newtonNthRoot(4, x);
    printf("x = %g\n", x);
    printf("z = newtonNthRoot(4, x) = newtonNthRoot(4, %g) = %g\n", x, z);
    printf("z*z*z*z = %g\n", z*z*z*z);
    printf("\n");

    x = 1.0/12960000000000000000.0;
    z = newtonNthRoot(4, x);
    printf("x = %g\n", x);
    printf("exp(log(x)/4.0) = %g\n", exp(log(x)/4.0));
    printf("z = newtonNthRoot(4, x) = newtonNthRoot(4, %g) = %g\n", x, z);
    printf("z*z*z*z = %g\n", z*z*z*z);
    printf("\n");

    errNo = setjmp( g_stkBuf );  // longjmp로 복귀할 지점을 설정, g_stkBuf에 스택정보 저장
    switch ( errNo )
    {
        case NO_EXCEPTION:
            x = -4.0;
            printf("[ Test Exception heronSqrt(double) ]--------------------\n");
            printf("x = %g\n", x);
            printf("Calculating heronSqrt(%g)\n" , x);
            y = heronSqrt(x);
            printf("y = heronSqrt(%g) = %g\n", x, y);
            printf("y*y = %g\n", y*y);
            printf("\n");
            break;
        case CANNOT_EVALUATE:
            printf("Caught some exception in calculating heronSqrt(%g)\n", x);
            printf("\n");
            errNo = NO_EXCEPTION;
            break;
    }

    errNo = setjmp( g_stkBuf );  // longjmp로 복귀할 지점을 설정, g_stkBuf에 스택정보 저장
    switch ( errNo )
    {
        case NO_EXCEPTION:
            x = -4.0;
            printf("[ Test Exception in newtonCbrt(double) ]--------------------\n");
            printf("x = %g\n", x);
            printf("Calculating newtonCbrt(%g)\n", x);
            y = newtonCbrt(x);
            printf("y = newtonCbrt(%g) = %g\n", x, y);
            printf("y*y*y = %g\n", y*y*y);
            printf("\n");
            break;
        case CANNOT_EVALUATE:
            printf("Caught some exception in calculating newtonCbrt(%g)\n", x);
            printf("\n");
            errNo = NO_EXCEPTION;
            break;
    }

    printf("[ Test calculations by powering ]-----------------------------\n");
    x = 200.0;
    z = newtonNthRoot(10, x);
    printf("x = %g\n", x);
    printf("exp(log(x)/10.0) = %g\n", exp(log(x)/10.0));
    printf("z = newtonNthRoot(10, x) = newtonNthRoot(10, %g) = %g\n", x,  z);
    printf("pow(z, 10) = %g\n", pow(z, 10));
    printf("\n");

    x = 3001.0;
    z = newtonNthRoot(99, x);
    printf("x = %g\n", x);
    printf("exp(log(x)/99.0) = %g\n", exp(log(x)/99.0));
    printf("z = newtonNthRoot(99, x) = newtonNthRoot(99, %g) = %g\n", x, z);
    printf("pow(z, 99) = %g\n", pow(z, 99));
    printf("\n");

    x = 3001.0;
    z = newtonNthRoot(-99, x);
    printf("x = %g\n", x);
    printf("exp(log(x)/-99.0) = %g\n", exp(log(x)/-99.0));
    printf("z = newtonNthRoot(-99, x) = newtonNthRoot(-99, %g) = %g\n", x, z);
    printf("1.0/pow(z, 99) = %g\n", 1.0/pow(z, 99));
    printf("\n");

    printf("2.1**2.1 = pow(2.1, 2.1) = %g\n", pow(2.1, 2.1));
    printf("2.1**(-2.1) = pow(2.1, -2.1) = %g\n", pow(2.1, -2.1));
    printf("2.1**2.1 * 2.1**(-2.1) = pow(2.1, 2.1) * pow(2.1, -2.1) = %g\n", pow(2.1, 2.1)*pow(2.1, -2.1));
    printf("2.1**2.1 = exp(2.1*log(2.1)) = %g\n", exp(2.1*log(2.1)));
    printf("2.1**(-2.1) = exp(-2.1*log(2.1)) = %g\n", exp(-2.1*log(2.1)));
    printf("2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = %g\n", exp(2.1*log(2.1)) * exp(-2.1*log(2.1)));
    printf("\n");

    k = 301;
    x = -1.029;
    t1 = nPow(x, k);
    t2 = gPow(x, k);
    t3 = mPow(x, k);
    printf("t1 = nPow(%g, %d) = %g\n", x, k, t1);
    printf("t2 = gPow(%g, %d) = %g\n", x, k, t2);
    printf("t3 = mPow(%g, %d) = %g\n", x, k, t3);
    printf("t1 / t2 = %g\n", t1 / t2);
    printf("t1 - t2 = %g\n", t1 - t2);
    printf("t1 == t2 ? %s\n",  t1 == t2 ? "yes" : "no");
    printf("t1 / t3 = %g\n", t1 / t3);
    printf("t1 - t3 = %g\n", t1 - t3);
    printf("t1 == t3 ? %s\n",  t1 == t3 ? "yes" : "no");
    printf("t2 / t3 = %g\n", t2 / t3);
    printf("t2 - t3 = %g\n", t2 - t3);
    printf("t2 == t3 ? %s\n",  t2 == t3 ? "yes" : "no");
    printf("\n");

    printf("Done.\n");

}

/*
Output:
[ Testing heronSqrt(double) ]--------------------
x = 16
u = sqrt(16) = 4
y = heronSqrt(16) = 4
y*y = 16

[ Testing newtonCbrt(double) ]--------------------
x = -216
-exp(log(-x)/3.0) = -6
w = newtonCbrt(-216) = -6
w*w*w = -216

x = 7.29e+011
exp(log(x)/3.0) = 9000
w = newtonCbrt(7.29e+011) = 9000
w*w*w = 7.29e+011

[ Testing newtonNthRoot(int, double) ]--------------------
x = 7.29e+011
z = newtonNthRoot(3, 7.29e+011) = 9000
z*z*z = 7.29e+011

x = 1.296e+019
z = newtonNthRoot(4, x) = newtonNthRoot(4, 1.296e+019) = 60000
z*z*z*z = 1.296e+019

x = 7.71605e-020
exp(log(x)/4.0) = 1.66667e-005
z = newtonNthRoot(4, x) = newtonNthRoot(4, 7.71605e-020) = 1.66667e-005
z*z*z*z = 7.71605e-020

[ Test Exception heronSqrt(double) ]--------------------
x = -4
Calculating heronSqrt(-4)
Cannot find the sqrt of a negative number.
Caught some exception in calculating heronSqrt(-4)

[ Test Exception in newtonCbrt(double) ]--------------------
x = -4
Calculating newtonCbrt(-4)
y = newtonCbrt(-4) = -1.5874
y*y*y = -4

[ Test calculations by powering ]-----------------------------
x = 200
exp(log(x)/10.0) = 1.69865
z = newtonNthRoot(10, x) = newtonNthRoot(10, 200) = 1.69865
pow(z, 10) = 200

x = 3001
exp(log(x)/99.0) = 1.08424
z = newtonNthRoot(99, x) = newtonNthRoot(99, 3001) = 1.08424
pow(z, 99) = 3001

x = 3001
exp(log(x)/-99.0) = 0.922308
z = newtonNthRoot(-99, x) = newtonNthRoot(-99, 3001) = 0.922308
1.0/pow(z, 99) = 3001

2.1**2.1 = pow(2.1, 2.1) = 4.74964
2.1**(-2.1) = pow(2.1, -2.1) = 0.210542
2.1**2.1 * 2.1**(-2.1) = pow(2.1, 2.1) * pow(2.1, -2.1) = 1
2.1**2.1 = exp(2.1*log(2.1)) = 4.74964
2.1**(-2.1) = exp(-2.1*log(2.1)) = 0.210542
2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = 1

t1 = nPow(-1.029, 301) = -5457.93
t2 = gPow(-1.029, 301) = -5457.93
t3 = mPow(-1.029, 301) = -5457.93
t1 / t2 = 1
t1 - t2 = 6.18456e-011
t1 == t2 ? no
t1 / t3 = 1
t1 - t3 = 6.18456e-011
t1 == t3 ? no
t2 / t3 = 1
t2 - t3 = 0
t2 == t3 ? yes

Done.
*/