1. What is Ch?
2. Why using the name Ch?
3. Is Ch a new language?
4. What are the differences between Ch and other languages and software packages?
5. What is the relation between Ch and C/C++?
6. What are Ch extensions to C?
7. What are the differences between Ch and Java™?
8. What are the differences between Ch and conventional Unix shells?
9. What are the differences between Ch and C++?
10. What are the differences between Ch and Fortran?
11. What are the differences between Ch and Basic?
12. What are the differences between Ch and mathematical packages?
13. How do you compare Ch with Perl and CGI?
14. Can Ch be used for World-Wide Distributed Computing?
15. On what platforms does Ch run?
16. Can Ch code be compiled into binary?
17. How can Ch code in ChIDE be exported in a Word file with syntax highlinghting?

Ch is an embeddable C/C++ interpreter for cross-platform scripting, shell programming, 2D/3D plotting, quick animation, numerical computing, and embedded scripting. C/Ch/C++ allow users to use one language, anywhere and everywhere, for any programming tasks. It is a scripting language like Perl, Python or Bash.

Q:Why using the name Ch?

Ch means C with high-level extensions. Also, Ch contains the initials of last and first name of Harry Cheng, the Ch chief architect.

Q:Is Ch a new language?

No, Ch is not a new language. Ch is C+. Similar to gcc, VC++® and Sun cc which are C compilers that conform to the C language standard ratified by ANSI and ISO, Ch is interpretive implementation of the C language. It supports C99, C++ class, POSIX, C LAPACK, CGI, OpenGL, ODBC, X/Motif, Win32 and GTK+.

Like all C compilers, our C interpreter also has some extensions to the C standard. Some extensions in Ch such as complex numbers and variable length arrays (VLAs) have been adopted in the latest ISO C standard called C99. Ch supports more new features in C99 than most existing C compilers. C99 features supported in Ch are listed here.

Q: What is the relation between Ch and other major computer programming languages and software packages?

The relation between Ch and other major computer programming languages and software packages can be illustrated in a diagram below.

Q: What is the relation between Ch and C/C++

C++ is C plus plus minus. Ch is C plus (Ch = C+). Ch is a C interpreter. Ch is C with classes and high-level extensions. Ch is a superset of C. Note that C++ is no longer a superset of C. For example, VLA and IEEE floating-point arithmetic in C are not supported in C++.

C is for low-level system programming and embedded systems; C++ for large-scale projects. Ch is optimal for platform-independent scripting in numerical computing and visualization, rapid application development, Web programming and plotting, embedded scripting, shell programming, integration with legacy systems, and learning C/C++.

Q:What are Ch extensions to C?

Like C++, Ch is designed to be a superset of C, which means a C program can run in Ch without modification. Unlike C++ which is designed for serious professional programmers (elite), Ch is designed for both novice beginners with no computer experience (average Joe and John) as well as experienced programmers. Many weakness in C is addressed in Ch. Major extensions to C in Ch are as follows.

• Cross platform shell programming
  Ch is C comptabile unix shell and it works in Windows/Linux/MacOSX/Unix. The shell features such as Foreach-loop, Here document, Verbatim output and variable substitution are supported. It can be used as a login shell in Unix/Linux/MacOSX.

• C++ Classes, objects, and encapsulation for object-based programming.

• Built-in array boundary check at run time
  the array boundary is checked when an element of array is accessed at run time. The string length is checked when an array of chars is updated as a string. The error will be issued when the array size exceeds its limit for safety operation.

• Embedded Scripting
  Ch can be embedded into C/C++ applications for embeddable scripting. The pointer can be used between C/C++ binary functions and Ch, no additioal wrapping code is needed. It is easy to call back the binary C functions from Ch script or call the Ch function from binary C space. The debug is also supported via embedded Ch API.

• Variables are initialized upon declaration
  Variables, pointers declaration and memories allocated by memory allocation functions are automatically initialized with 0 or NULL.

• Support reflection It is easy to evaluate a string at run time with streval().

• Support function overloading and polymorphism with variable arguments in a function
  Standard C requires at least one fixed argument. Ch extends C with more flexibility. It supports variable length argument without specifying the first named argument in the form of "type funcname(...)". Thus the number and types of arguments are flexible. It can be used for overloading and polymorphism.

• Computational array for numerical computing
  An array qualified by type qualifier array is called computational array. A computational array is treated as a first-class object as in Fortran 90. For example,

         #include <array.h>
         array float a[10][10], b[10][10];
         a += b+inverse(a)*transpose(a)+sin(a);
  

• Mathematical function extensions
  Follow conventional mathematics in complex analysis, there is only one complex infinity and one complex-not-a-number. Complex numbers are defined in the entire complex domain with complex metanumbers ComplexInf and ComplexNaN. Different branches of multiple-valued complex functions can be obtained by mathematical functions with optional arguments. For example, the square root of -1 has two values of unit imaginary numbers i and -i. They can be obtained by generic function sqrt() in Ch as follows.

  > sqrt(-1.0)
  NaN
  > sqrt(complex(-1.0,0))
  complex(0.0000,1.0000)
  > sqrt(complex(-1.0,0), 0)
  complex(0.0000,1.0000)
  > sqrt(complex(-1.0,0), 1)
  complex(-0.0000,-1.0000)
  > sqrt(-1, 0)
  complex(0.0000,1.0000)
  > sqrt(-1, 1)
  complex(-0.0000,-1.0000)
  >
  

• Support string data type String is a first-class object in Ch, it can allocate and deallocate the memory automatically. For example,

        string_t s, a[3];
        s = "great string";
        strcpy(a[0], s);
        strcat(s, s);
        printf("s = %s\n", s);
  

• Functions can be nested and recursively nested similar to its implementation in GNU gcc.
  For example,

        int func1() {
           void func2() {
              int func3() { ...}
           }
           ...
           func2();
        }  
  

• Extentions for deferred-shape arrays, assumed-shape arrays, and pointer to assumed-shape arrays
  Multi-dimensional arrays in C are difficult to handle with double pointers. They are valid in Ch. But, arrays of variable length (VLA) including deferred-shape arrays, assumed-shape arrays, and pointer to assumed-shape arrays in Ch provide more elegant interface. The following example demonstrates the simplicity of VLA.

    void funct(int a[:][:], (*b)[:], n, m){
    /* a: assumed-shape array */
    /* b: pointer to its array of assumed-shape */
      int e[n][m];     /* e: deferred-shape array */
      int (*f)[:];     /* f: pointer to array of assumed-shape */
      f = a;
      e[1][2] = a[2][3];
    }
    int A[3][4], B[5][6];
    funct(A, B, 10, 20);
    funct(B, A,  85, 85);
  

• Arrays of adjustable range. The range of subscript for an index of array can be adjusted. For example,

    int a[1:10], b[-5:5], c[0:10][1:10], d[10][1:10], e[n:m], f[n1:m1][1:m2];
    extern int a[1:], b[-5:], c[0:][1:10];
    int funct(int a[1:], int b[1:10], int c[1:][3], int d[1:10][0:20]);
    a[10] = a[1]+2; /* OK */
    a[0] = 90;      /* Error: index out of range */
  

    void funct2(int a[0:]) {
        int i;
        int num=(int)shape(a); // num is 10, 10, 11 for a1, a2, a3, respectively
        for(i=0; i<num; i++) {
           a[i] *= 2;  /* multiply each element of the array by 2 */
        }
    }
    int main() {
       int a1[10];    // a[0], ... a[8], a[9]
       int a2[1:10];  // a[1], ... a[9], a[10]
       int a3[0:10];  // a[0], ... a[8], a[9], a[10]
       /* ... */
       funct2(a1);
       funct2(a2);
       funct2(a3);
    }
  
  

• Reference type
  Functions can be called by reference. The same syntax in C++ is used in Ch. For example,

    void swap(int& i, int& j){
      int tmp = i;
      i = j;
      j = tmp;
    }
    int main() {
      int i;
      int &j = i;
      int A, B;
      swap(A, B);    /* pass by reference as in Fortran */
    }
  

• cross platform built-in 2D/3D graphical plottings
  High-level function files such as plotxy(), plotxyz(), plotxyf(), plotxyzf() for plotting. For example, the following Ch program can plot a sine wave on your screen without compilation.

      #include <math.h>
      #include <chplot.h>
      int main() {
          int numpoints = 36;
          array double x[numpoints], y[numpoints];
  
          linspace(x, 0, 360);
          y = sin(x*M_PI/180);
          plotxy(x, y, "Ch plot", "xlabel", "ylabel");
      }
  

• The index of a switch statement can be string in addition to integral constants.
  For example,

  string_t hostname=`hostname`;
  switch (hostname) {
      case "workmachine":
          fetchmail;
          break;
      case "homemachine":
          echo Ch is cool! I can now use a C program to backup files
          dump 0ubdsf 80 50000 50000 /dev/nrst0 /dev/sd0a
          break;
      default:
          break;
  }
  

• A member of class/struct/union can be a pointer to assumed-shape arrays.
  That means a member of class/struct/union can be an array of variable length. This powerful feature can be illustrated by the following interactive commands executed in a Ch shell.

  > struct tag {             \
  >    int (*a)[:];          \ 
  >    array int (*b)[:];    \
  > }s 
  > int a1[2][3], a2[3][4]
  > array int b1[2][3]= {1,2,3,4,5,6}
  > array int b2[3][4]= {1,2,3,4,5,6,7,8,9,10,11,12}
  > s.a = a1; /* s.a and a1 share the memory */s
  > a1[1][2] = 10;
  > s.a[1][2] 
  10
  > s.a = a2; /* s.a and a2 share the memory */
  > s.a[1][2] = 20
  > a2[1][2] 
  20
  > a1[1][2] 
  10
  > s.b = (array int [:][:])b1
  > s.b 
  1 2 3 
  4 5 6 
  > s.b[1][1] = 100
  > b1
  1 2 3 
  4 100 6 
  > s.b = (array int [:][:])b2
  1 2 3 4 
  5 6 7 8 
  9 10 11 12 
  >
  

• Array of reference is supported
  Arrays of different shape and data type can be passed to arguments of functions with array of reference type.

• Support hexadecimal format '%x' in printf(), sprintf() etc functions

  decimal	octal	hexadecimal	binary
  printf("%d", 15);	printf("%o", 15);	printf("%x", 15);	printf("%b", 15);

Q: What are the differences between Ch and Java™?

Comparing Ch with Java™ is like comparing an orange with an apple. These two language environments are quite different in many ways. However, the following notes highlight the similarities and differences between Ch applets and Java™ applets for network computing.

Similarities between Ch and Java™

• Both are interpretive.
• Both treat string data type as a first-class object.
• Both can pass information by reference.
• The sizes of non-aggregate data types are fixed .

Export the code in .RTF or PDF file first using the commands "File", "Export", "As RTF" or "As PDF".