1. Easy Language

1.1. What is the Easy Language ?

The EZ (Easy) language is a simple yet powerful language close to C++. The source code of the language is translated to C++ and then compiled by a C++ compiler. The aim of the language is to simplify the writing of algorithms and the annoyances of C++.

1.2. Language definition

1.2.1. Types of the Language ?

Each type has built-in methods, for exemple in the case of integers :

for strings :

for vectors :

1.2.1.a  Variables definition

We use the keyword var to introduce a list of variables

  1. // definition of a simple variable
  2. var int n
  3.  
  4. // initialization
  5. var int x = 1, y, z = 2
  6.  
  7. var string s = "hello"
  8.  
  9. // ------------------------------------------------------------------  
  10. // containers
  11. // ------------------------------------------------------------------  
  12.  
  13. // definition of a vector  
  14. var vector<int> v
  15.  
  16. // definition of a vector of size 10 with first three elements
  17. // defined
  18. var vector<int> v(10) = { 1, 2, 3 }
  19.  
  20. // definition of two arrays that range from -3 to +3
  21. var array<int>[ -3 .. 3 ] tab1, tab2
  22.  

1.2.2. Instructions

For the sake of simplicity, the following rules must be respected:

The main instructions are the following:

if

  1. if x < 1 then
  2.   println( "x < 1")
  3. elsif x < 10 then
  4.   println( "1 <= x < 10" )
  5. else
  6.   println( "x >= 10" )
  7. endif
  8.  

on do

  1. // on <condition> do <simple-instruction>
  2.  
  3. on x < 1 do return false
  4.  

while

  1. var int i = 1, sum = 0
  2.  
  3. // compute sum of the integers from 1 to 10
  4.  
  5. while i <= 10 do
  6.  
  7.   sum += i  // or sum = sum + i
  8.   ++i     // or i = i + 1
  9.  
  10. end while
  11.  
  12.  
  13.  

repeat until

  1. var int i = 1, sum = 0
  2.  
  3. // compute sum of the integers from 1 to 10
  4.  
  5. repeat
  6.  
  7.   sum += i  // or sum = sum + i
  8.   ++i     // or i = i + 1
  9.  
  10. until i > 10
  11.  
  12.  

for

  1. // i is defined as an integer by default
  2. // if i already exists a warning will be issued
  3.  
  4. var int sum = 0
  5.  
  6. // compute sum of the integers from 1 to 10
  7.  
  8. for i in range(1,10) do
  9.  
  10.   sum += i
  11.  
  12. end for
  13.  

loop

  1. var int i = 1, sum = 0
  2.  
  3. // compute sum of the integers from 1 to 10
  4.  
  5. loop 10
  6.  
  7.   sum += i  // or sum = sum + i
  8.   ++i     // or i = i + 1
  9.    
  10. end loop
  11.  

switch

  1. switch x
  2.   case 1
  3.     println "x = 1"
  4.   end case
  5.  
  6.   case 2
  7.     println "x = 2"
  8.   end case
  9.  
  10.   default case
  11.     println "x is not equal to 1 or 2"
  12.   end case
  13.  
  14. end switch
  15.  

print, read, ask, dump

  1. var int i = 3
  2. var string name = "John"
  3.  
  4. // print different data
  5. print "a string ", 10, 'c', 3.1415, " ", name
  6.  
  7. // print variable type and value
  8. dump name, i
  9.  
  10. // read from standard input
  11. ask name
  12.  

Examples

The Hello World ! program in EZ

  1. prog hello_world
  2.  
  3. // -----------------------------------------
  4. // a procedure that has the same name as the
  5. // program is the entry point
  6. // -----------------------------------------
  7. proc hello_world()
  8.  
  9.   println "Hello World !"
  10.  
  11. end proc
  12.  

First 20 Prime numbers and their average

The following program computes the first 20 prime numbers using the user defined function 'is_prime'. Once these numbers are found we can compute their average.

  1. prog prime_numbers
  2.  
  3. arguments
  4.   int max_primes as "mp" = 20
  5. end arguments
  6.  
  7. var vector<int> v
  8.  
  9. /* =====================================
  10.  * function that determines if 'x' is
  11.  * a prime number or not
  12.  * =====================================
  13.  */
  14.  
  15. func bool is_prime( int x )
  16.   on n <= 1 do return false
  17.   on n <= 3 do return true
  18.   on (n % 2) = 0 do return false
  19.  
  20.   // no need to declare variable i it will be declared
  21.   // in C++ by "for (int i = 3; i <= x.sqrt(); i += 2)"
  22.  
  23.   for i in range(3, x.sqrt(), 2)
  24.  
  25.     on (x % i) = 0 do return false
  26.    
  27.   end for
  28.  
  29.   return true
  30.  
  31. end func
  32.  
  33. // =====================================
  34. // start program here
  35. // =====================================
  36.  
  37. proc prime_numbers()
  38.  
  39.   var int n = 1
  40.  
  41.   while (v.size() != max_primes) and (n <= 1000) do
  42.  
  43.     on is_prime(n) do v.insert_last(n)
  44.     ++n
  45.    
  46.   end while
  47.  
  48.   println "the first ", MAX_PRIMES, " numbers are ", v
  49.   println "their average is ", v.average()
  50.  
  51. end proc
  52.  
  53.  

This program will be translated in C++ as the following:

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4. #include "ez.h"
  5.  
  6. const int MAX_PRIMES = 20;
  7. int n;
  8.  
  9. bool is_prime(int x) {
  10.   int i;
  11.  
  12.   if (n <= 1) return false;
  13.   if (n <= 3) return true;
  14.   for (i = 2; i <= x/2; ++i) {
  15.     if ((x % i) == 0) return false;
  16.   }
  17.  
  18.   return true;
  19. }
  20.  
  21.  
  22. int main() {
  23.   ez::vector<int> v;
  24.  
  25.   n = 1
  26.   while (v.size() < MAX_PRIMES) {
  27.     if (is_prime(n))  v.push_back(n);
  28.     n += 1;
  29.   }
  30.   cout << "the first " << MAX_PRIMES << " numbers are " << v << endl;
  31.   cout <<  "their average is " << v.average() << endl;
  32.   return EXIT_SUCCESS;
  33. }
  34.  

User-defined data structure

The following program creates a vector of persons and sort them by name, by age and computes maximum of ages

  1. prog prog_person
  2.  
  3. import math
  4.  
  5. /**
  6.  * definition of a person,
  7.  * default methods will be created for this class
  8.  * - a constructor with no arguments that initializes all data members
  9.  * - a constructor with arguments for each data members except containers
  10.  * - a print method to display all data members
  11.  */
  12. class Person  
  13.  
  14.   var string name
  15.   var int age
  16.  
  17. end class
  18.  
  19. // =====================================
  20. // start program here
  21. // =====================================
  22. proc prog_person()
  23.  
  24.   var Person p
  25.   var vector<Person> v
  26.   var int i, max
  27.  
  28.   for i in range(1,10) do
  29.     p.name = "p" + i
  30.     p.age = math.rand( 1, 100 )
  31.     v.insert(p)
  32.   end for
  33.  
  34.   // sort by name
  35.   v.sort( name );
  36.   println v
  37.  
  38.   // store to file and restore from file 
  39.   v.store( "persons.txt" )
  40.   v.empty()
  41.   v.restore( "persons.txt" )
  42.  
  43.   // sort by age 
  44.   v.sort( age )
  45.  
  46.   // compute maximum of ages (detailed version)
  47.   max = 0
  48.   for i in v.range()
  49.    
  50.     on v[i].age > max do max = v[i].age
  51.    
  52.   end for
  53.  
  54.   // or use built-in function
  55.   max = v.max(age)
  56.  
  57.   println "oldest person is ", max, " years old"
  58.  
  59. end
  60.  
  61.  

This program will be translated in C++ as the following:

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4. #include "ez.h"
  5.  
  6. class Person {
  7. public:
  8.   string name;
  9.   int age;
  10.  
  11.   Person() {
  12.     name = "";
  13.     age = 0;
  14.   }
  15.  
  16.   ostream& print(ostream& out) {
  17.     out << name << ", " << age;
  18.   }
  19.  
  20.   ostream& _export(ostream& out) {
  21.     out << name << ", " << age;
  22.   }
  23.  
  24.   ostream& operator<<(ostream& out, Person& obj) {
  25.     return obj.print(out);
  26.   }
  27. };
  28.  
  29. int main() {
  30.   Person p;
  31.   ez::vector<Person> v;
  32.   int i, max;
  33.  
  34.  
  35.   for (i = 1; i <= 10; ++i) {
  36.     p.name = "p" + i;
  37.     p.age = 1 + rand() % 100;
  38.     v.push_back(p);
  39.   }
  40.  
  41.   // sort by name
  42.   sort(v.begin(), v.end(), [](const Person& lhs, const Person& rhs) {
  43.     return lhs.name > rhs.name;
  44.   });
  45.  
  46.   cout << v;
  47.   v.store("persons.txt")
  48.   v.clear()
  49.   v.restore("persons.txt")
  50.  
  51.   // sort by age
  52.   sort(v.begin(), v.end(), [](const Person& lhs, const Person& rhs) {
  53.     return lhs.age > rhs.age;
  54.   });
  55.  
  56.  
  57.   // compute maximum of ages (detailed version)
  58.   max = 0
  59.   for (i = 1; i <= v.size(); ++i) do
  60.     if  (v[i].age > max) max = v[i].age;
  61.   }
  62.  
  63.   // or use built-in function
  64.   max = v.max(age)
  65.  
  66.   cout << "maximum of ages = " << max << endl;
  67. end
  68.  
  69.  

Input and Output parameters

  1. prog parameters
  2.  
  3. arguments
  4.   int x as "x" required = 1
  5.   int y as "y" required = 1
  6. end arguments
  7.  
  8. /* ------------------------------------------------------------------
  9.  * by default any parameter declared is considered as 'input'
  10.  * which means non modifiable.
  11.  * Here z is an output parameter
  12.  * ------------------------------------------------------------------
  13.  */
  14. proc add( int x, y, int& z )
  15.  
  16.   z = a + b
  17.  
  18. end
  19.  
  20. /* ------------------------------------------------------------------
  21.  * It all starts here !
  22.  * ------------------------------------------------------------------
  23.  */
  24. proc parameters()
  25.  
  26.   var int z
  27.  
  28.   add(x, y, z)
  29.  
  30.   dump z
  31.  
  32. end
  33.  

This program will be translated in C++ as the following:


Warning: file_get_contents(ez/parameters.cpp): failed to open stream: No such file or directory in /home/jeanmichel.richer/public_html/html_business.php on line 448
  1.  

Merge sort

  1. prog merge_sort_program
  2.  
  3. /*
  4.  * Command line argument of the program which must be provided as
  5.  *    -s <integer-constant>
  6.  * or
  7.  *    --array-size=<integer-constant>
  8.  */
  9. arguments
  10.   int array_size as 's', "array-size" = 10
  11. end arguments
  12.  
  13. /* ------------------------------------------------------------------
  14.  *
  15.  * SUBPROGRAM
  16.  *
  17.  *  proc merge( array<int>& t, int l, m, h )
  18.  *
  19.  * WHAT
  20.  *
  21.  *  Merge two parts consecutive parts of the array @param(t)
  22.  *
  23.  * PARAMETERS
  24.  *
  25.  *  @paramdef(t) array of integers
  26.  *  @paramdef(l) lowest index of array to merge
  27.  *  @paramdef(m) middle index of array to merge
  28.  *  @paramdef(h) highest index of array to merge
  29.  *
  30.  * ------------------------------------------------------------------
  31.  */
  32. proc merge( array<int>& t, int l, m, h )
  33.  
  34.   var int i = l, j = m, k = l
  35.   var array<int> temp;
  36.  
  37.   while (i < m) and (j <= h) do
  38.     if t[ i ] < t[ j ] then
  39.       temp[ k ] = t[ i ]
  40.       ++k
  41.       ++i
  42.     elsif t[ j ] < t[ i ] then
  43.       temp[ k ] = t[ j ]
  44.       ++k
  45.       ++j
  46.     else
  47.       temp[ k ] = t[ j ]
  48.       temp[ k ] = t[ i ]
  49.       ++i
  50.       ++j
  51.       k += 2
  52.   end while
  53.  
  54.   while i < m do
  55.     temp[ k ] = t[ i ]
  56.       ++k
  57.       ++i
  58.   end while
  59.  
  60.   while j <= h do
  61.     temp[ k ] = t[ j ]
  62.     ++k
  63.     ++j
  64.   end while
  65.  
  66.   t = temp
  67.  
  68. end proc
  69.  
  70.  
  71. /* ------------------------------------------------------------------
  72.  *
  73.  * SUBPROGRAM
  74.  *
  75.  *  proc split( array<int>& t, int l, h )
  76.  *
  77.  * WHAT
  78.  *
  79.  *  Split array @param(t) in two parts based on middle index
  80.  *  defined by @formula( (l+h) / 2 ).
  81.  *
  82.  * PARAMETERS
  83.  *
  84.  *  @paramdef(t) array of integers
  85.  *  @paramdef(l) lowest index of array to split
  86.  *  @paramdef(h) highest index of array to split
  87.  *
  88.  * ------------------------------------------------------------------
  89.  */
  90.  
  91. proc split( array<int>& t, int l, h )
  92.  
  93.   // number of elements of the
  94.   var int size = h - l + 1
  95.  
  96.   on size = 1 do return
  97.  
  98.   if size = 2 then
  99.     on t[l] > t[h] do t.swap(l, h)
  100.  
  101.   else
  102.  
  103.     int m = (l + h) / 2
  104.     split( t, l, m-1 )
  105.     split( t, m, h )
  106.    
  107.     merge( t, l, m, h )
  108.  
  109.   end if
  110.    
  111. end proc
  112.  
  113. /* ------------------------------------------------------------------
  114.  *
  115.  * SUBPROGRAM
  116.  *
  117.  *  proc merge_sort( array<int>& t )
  118.  *
  119.  * WHAT
  120.  *
  121.  *  Perform merge-sort on array @param(t)
  122.  *
  123.  * PARAMETERS
  124.  *
  125.  *  @paramdef(t) array of integers
  126.  *
  127.  * ------------------------------------------------------------------
  128.  */
  129.  
  130. proc merge_sort( array<int>& t )
  131.  
  132.   split( t, t.min_index(), t.max_index() )
  133.  
  134. end proc
  135.  
  136. /* ------------------------------------------------------------------
  137.  *
  138.  * SUBPROGRAM
  139.  *
  140.  *  proc merge_sort_program()
  141.  *
  142.  * WHAT
  143.  *
  144.  *  Main method
  145.  *
  146.  * NOTE
  147.  *
  148.  *  @var(array_size) is a parameter of the program provided
  149.  *  as a command line argument (@see arguments section).
  150.  *
  151.  * ------------------------------------------------------------------
  152.  */
  153. proc merge_sort_program()
  154.  
  155.   // check condition, if false then raise exception
  156.   assume array_size > 1
  157.  
  158.   // create array
  159.   var array<int> t[ 1 .. array_size ]
  160.  
  161.   t.random_fill( 20, 1500 )
  162.  
  163.   merge_sort( t )
  164.  
  165.   print t
  166.  
  167. end proc
  168.  

1.3. Compilation process

The EZ language source file must have the .ezl extension.

The compiler is called ezc and uses some compilation flags :

By default the compiler will try to generate the C++ file, compile it into and executable and run it.