Thursday, February 27, 2014

Arrays and Indexers in IronRuby



Today's post is about Arrays and Indexers in IronRuby. Here below you will find a very easy to follow program, that demonstrate arrays and indexer, by implementing some simple tasks that will make you grasp the idea of those 2 features real quick. The main goal of this post, is not really teaching arrays because, come on, you probably already know "all" about them, in fact, it is more to show you how you do that in IronRuby, in this case, compared to all other 22 languages on future posts, which essentially, is the real aim behind this blog.

This is the last of the .NET dynamic languages. I'm considering to stop writing about it because the project seems to be dead with no updates since 13/03/11)... will see, probably this will be the last post about it if no news, fortunately, there is still JRuby.

By the way, if you missed my most recent post, "New Series - Arrays and Indexers", check it out. It has more details about the following program, and a bunch of definitions for the concepts used on this, and the following, posts. Or you can check my previous posts about arrays in JRuby, later on, just to compare.

I encourage you to copy the code below and try it yourself, normally, all programs you find in this blog are source code complete, just paste it on your IDE and run it.

There is room for improvement of the code, using generics is one example, but Generics, Collections, lambdas, etc. will have their own "series" of posts.


require "mscorlib" 
include System

# Console Program
def main()
    # Single-dimensional Array(s)
    print_title("Reverse Array Elements")
 
    # Declare and Initialize Array of Chars      
    letters = Array.new(5," ")
    letters[0] = "A"
    letters[1] = "E"
    letters[2] = "I"
    letters[3] = "O"
    letters[4] = "U"
 
    print_array(letters)  
    inverse_letters = reverse_char(letters)
    print_array(inverse_letters)

    print_title("Sort Integer Array Elements")
    # Declare and Initialize Array of Integers   
    numbers = [10, 8, 3, 1, 5]
    
    print_array(numbers)       
    ordered_numbers = bubblesort(numbers)   
    print_array(ordered_numbers)

    print_title("Sort String Array Elements")  
 
    # Declare and Initialize and Array of Strings 
    #names = Array.new(5, ["Damian","Rogelio","Carlos","Luis","Daniel"])
    # or just 
    names = ["Damian", 
      "Rogelio", 
      "Carlos", 
      "Luis", 
      "Daniel"]

    print_array(names)   
    ordered_names = bubblesort(names)   
    print_array(ordered_names)

    # Multi-dimensional Array (Matrix row,column)   
    print_title("Transpose Matrix")   

    # for an empty table initialized to 0s
    # matrix = Array.new(rows,0) { Array.new(cols,0) }
    matrix = [[6, 4, 24],      
              [1, -9, 8]]

    print_matrix(matrix)
    transposed_matrix = transpose_matrix(matrix)   
    print_matrix(transposed_matrix)  
 
    # Jagged Array (Array-of-Arrays)   
    print_title("Upper Case Random Array & Graph Number of Elements")   

=begin
# Creating an array of string arrays using the String.Split method   
# instead of initializing it manually as follows:   
# 
# text = [    
#  [ ["word1", "word2, "wordN"],    
#  [ ["word1", "word2, "wordN"],    
#  ...
#  ]   
#     
# Text extract from: "El ingenioso hidalgo don Quijote de la Mancha"        
=end
    text = [
    "Hoy es el dia mas hermoso de nuestra vida, querido Sancho;".split(" "),    
    "los obstaculos mas grandes, nuestras propias indecisiones;".split(" "),    
    "nuestro enemigo mas fuerte, miedo al poderoso y nosotros mismos;".split(" "),    
    "la cosa mas facil, equivocarnos;".split(" "),    
    "la mas destructiva, la mentira y el egoismo;".split(" "),    
    "la peor derrota, el desaliento;".split(" "),    
    "los defectos mas peligrosos, la soberbia y el rencor;".split(" "),    
    "las sensaciones mas gratas, la buena conciencia...".split(" ")
    ] 
 
    print_jagged_array(text)   
    uppercase_random_array(text)      
    print_jagged_array(text)   
    graph_jagged_array(text)

    # Array Exceptions
    print_title('Common Array Exceptions')
    
    print_common_array_exceptions(nil)
    print_common_array_exceptions(text)  

    # Accessing Class Array Elements through Indexer
    print_title('Alphabets')
    
    vowels = Alphabet.new(5)
    vowels[0] = "a"
    vowels[1] = "e"
    vowels[2] = "i"
    vowels[3] = "o"
    vowels[4] = "u"

    puts "\nVowels={%s}" % [vowels[0],vowels[1],vowels[2],vowels[3],vowels[4]].join(",")

    en = Alphabet.new("abcdefghijklmnopqrstuvwxyz")   

    puts "English Alphabet = {%s}" % [en]

    puts "Alphabet Extract en[9..19] = {%s}" % [Alphabet.new(en.slice(9, 10))]

    word1 = [en[6],en[14],en[14],en[3]].join("")
    word2 = [en[1],en[24],en[4]].join("")   
    word3 = [en[4],en[21],en[4],en[17],en[24],en[14],en[13],en[4]].join("")   
    puts "\n%s %s, %s!\n" % [word1, word2, word3]
 
    gets
end

def reverse_char(arr)
    arr.reverse
end 

def bubblesort(arr)  
    for i in arr.reverse
        for j in (0..arr.count-2)
            if arr[j] > arr[j + 1]    
                swap = arr[j]   
                arr[j] = arr[j + 1]   
                arr[j + 1] = swap   
            end    
        end 
    end   
    arr
end

def transpose_matrix(m)  
=begin
# Transposing a Matrix 2,3  
#     
#   A =  [6  4 24]T [ 6  1]  
#        [1 -9  8]  [ 4 -9]  
#                [24  8]  
=end
    transposed = Array.new(m[0].size) { Array.new(m.size) } 
    for i in 0..(m.size-1)   
        for j in 0..(m[0].size-1)   
            transposed[j][i] = m[i][j]
        end
    end
    transposed  
end

def uppercase_random_array(arr)      
    r = System::Random.new
    i = r.next(arr.size)
    for j in 0..(arr[i].size-1)   
        arr[i][j] = arr[i][j].upcase
    end
end

def print_array(arr)
    puts "\nPrint Array Content #{arr.GetType().Name}[#{arr.size}]"
    for i in 0..(arr.size-1)
        puts " array [%2s] = %2s" % [i, arr[i]]
    end
end

def print_matrix(m)
    puts "\nPrint Array Content #{m.GetType().Name}[#{m.size}][#{m[0].size}]"
    for i in 0..(m.size-1)
        for j in 0..(m[0].size-1)
            puts " array [%2s,%2s] = %2s" % [i, j, m[i][j]]
        end
    end
    m
end

def graph_jagged_array(arr)
=begin
# When using Arrays, we can use for(each) instead of for by index
#    for s in arr  
#        for w in s 
#        end
#    end
=end 
    puts "\nPrint Text Content #{arr.GetType().Name}"
    for i in 0..(arr.size-1)  
        line = ""
        line += "Line %2s|" % (i+1).to_s 
        for j in 0..(arr[i].size-1)   
            line += " * "
        end            
        line += "(#{arr[i].size})"
        puts line
    end
end

def print_jagged_array(arr)
    puts "\nPrint Jagged Array Content #{arr.GetType().Name}"
    for i in 0..(arr.size-1)
        line = ""
        for j in 0..(arr[i].size-1)     
            line += " " + arr[i][j]
        end
        if line == line.upcase
            line += " <-- [UPPERCASED]"
        end
        puts line
    end
end

def print_common_array_exceptions(arr)
    begin  
        arr.fetch(100)
    rescue Exception => ex
        puts "\nException: \n%s\n%s" % [ex.GetType().Name, ex.message]
    #else
    #   others
    end
end

def print_title(message)   
    puts ""  
    puts ("=" * 54)   
    puts message   
    puts ("=" * 54)
end     


class Alphabet
    # Array Field   
    @letters = []

    # Indexer Get/Set Property
    def [](idx)
        @letters[idx]
    end
    def []=(idx, value)
        @letters[idx] = value.upcase
    end
    
    # Read-Only Getter
    def length
        @letters.size
    end          

    # Constructor/Initializer
    def initialize(param)  
        if param.class == 1.class
            @letters = Array.new(param, " ")
        elsif param.class == "".class
            @letters = param.upcase.chars.to_a
        elsif param.class == [].class
            @letters = param
        else
            @letters = nil
        end
    end

    # Overridden Method    
    def to_s
        @letters.join(",")
    end
 
    # Method   
    def slice(start, length)
        @letters[start..start+length-1]
    end

end

main


The output:






















































































Voilà, that's it. Next post in the following days.

Tuesday, February 25, 2014

Arrays and Indexers in IronPython



Today's post is about Arrays and Indexers in IronPython. Here below you will find a very easy to follow program, that demonstrate arrays and indexer, by implementing some simple tasks that will make you grasp the idea of those 2 features real quick. The main goal of this post, is not really teaching arrays because, come on, you probably already know "all" about them, in fact, it is more to show you how you do that in IronPython, in this case, compared to all other 22 languages on future posts, which essentially, is the real aim behind this blog.

This is the second post of a dynamic language. As with Phalanger's version of the program, code structure changed slightly from previous posts. Besides that, because you normally don't use Arrays per se in Python (except for numerical arrays when better performance is required), it is more practical to use Python's List object instead of .NET's System.Array, which can definitely be used in IronPython, specially when you need to inter operate with other CLS languages. You can even initialize a System.Array with a Python List like this: System.Array[int]([1, 2, 3]).

By the way, if you missed my most recent post, "New Series - Arrays and Indexers", check it out. It has more details about the following program, and a bunch of definitions for the concepts used on this, and the following, posts. Or you can check my previous posts about arrays in Boo (or Cobra or Jython later on) just to compare.

I encourage you to copy the code below and try it yourself, normally, all programs you find in this blog are source code complete, just paste it on your IDE and run it.

There is room for improvement of the code, using generics is one example, but Generics, Collections, lambdas, etc. will have their own "series" of posts.


import clr
clr.AddReference("System")
import System
from System import Random
 
# Console Program   
def main():   
    # Single-dimensional Array(s)   
    printtitle('Reverse Array Elements'); 

    # Declare and Initialize Array (Python List) of Chars   
    # or letters = list('AEIOU')
    # or letters = 5 * [' ']      
    letters = list(' ' * 5) # letters = []
    letters[0] = 'A'        # letters.append('A')
    letters[1] = 'E'        # letters.append('E')
    letters[2] = 'I'        # letters.append('I')
    letters[3] = 'O'        # letters.append('O')
    letters[4] = 'U'        # letters.append('U')
    
    printarray(letters)
    inverse_letters = reversechar(letters)
    printarray(inverse_letters)

    printtitle('Sort Integer Array Elements')
    # Declare and Initialize Array of Integers   
    numbers = [10, 8, 3, 1, 5]
    
    printarray(numbers)   
    ordered_numbers = bubblesort(numbers)   
    printarray(ordered_numbers)

    printtitle('Sort String Array Elements')  

    # Declare and Initialize and Array of Strings   
    names = ['Damian', 'Rogelio', 'Carlos', 'Luis', 'Daniel']

    printarray(names)   
    ordered_names = bubblesort(names)   
    printarray(ordered_names)

    # Multi-dimensional Array (Matrix row,column)   
    printtitle('Transpose Matrix')   

    matrix = [[6, 4, 24],      
              [1, -9, 8]]

    printmatrix(matrix)
    transposed_matrix = transposematrix(matrix)   
    printmatrix(transposed_matrix)  

    # Jagged Array (Array-of-Arrays)   
    printtitle('Upper Case Random Array & Graph Number of Elements')   

    '''
    Creating an array of string arrays using the String.Split method   
    instead of initializing it manually as follows:   
 
    $text = [    
        [ ["word1", "word2, "wordN"],    
        [ ["word1", "word2, "wordN"],    
        ...
    ]   
     
    Text extract from: "El ingenioso hidalgo don Quijote de la Mancha"        
    '''
    text = [
    'Hoy es el dia mas hermoso de nuestra vida, querido Sancho;'.split(' '),    
    'los obstaculos mas grandes, nuestras propias indecisiones;'.split(' '),    
    'nuestro enemigo mas fuerte, miedo al poderoso y nosotros mismos;'.split(' '),    
    'la cosa mas facil, equivocarnos;'.split(' '),    
    'la mas destructiva, la mentira y el egoismo;'.split(' '),    
    'la peor derrota, el desaliento;'.split(' '),    
    'los defectos mas peligrosos, la soberbia y el rencor;'.split(' '),    
    'las sensaciones mas gratas, la buena conciencia...'.split(' ')
    ]

    printjaggedarray(text)   
    uppercaserandomarray(text)   
    printjaggedarray(text)   
    graphjaggedarray(text)

    # Array Exceptions
    printtitle('Common Array Exceptions')
    
    printcommonarrayexceptions(None)   
    printcommonarrayexceptions(text)  

    # Accessing Class Array Elements through Indexer
    printtitle('Alphabets')  
    
    vowels = Alphabet(5)
    vowels[0] = 'a'
    vowels[1] = 'e'
    vowels[2] = 'i'
    vowels[3] = 'o'
    vowels[4] = 'u'

    print '\nVowels = {%s}' % ','.join([vowels[0],vowels[1],vowels[2],vowels[3],vowels[4]])

    en = Alphabet('abcdefghijklmnopqrstuvwxyz')   
    print 'English Alphabet = {%s}' % (str(en))

    print 'Alphabet Extract en[9..19] = {%s}' % (str(Alphabet(en.slice(9, 10))))
   
    word1 = ''.join([en[6], en[14], en[14], en[3]])
    word2 = ''.join([en[1], en[24], en[4]])   
    word3 = ''.join([en[4], en[21], en[4], en[17], en[24], en[14], en[13], en[4]])   
    print "\n%s %s, %s!\n" % (word1, word2, word3)  

    raw_input()

def reversechar(arr):
    return list(reversed(arr))
    # or 
    # return arr[::-1]
    # or 
    # reversedarr = [], i = 0
    # for j in range(len(arr) - 1,-1,-1):
    #   reversedarr[i] = arr[j]
    # return reversedarr
    #

def bubblesort(arr):
    for i in reversed(arr):   
        for j in range(len(arr) - 1):   
            if arr[j] > arr[j + 1]:   
                swap = arr[j]   
                arr[j] = arr[j + 1]   
                arr[j + 1] = swap   
    return arr

def transposematrix(m):   
    ''' Transposing a Matrix 2,3  
     
     A =  [6  4 24]T [ 6  1]  
          [1 -9  8]  [ 4 -9]  
                     [24  8]  
    '''
    transposed = [len(m)*[0] for i in range(len(m[0]))]
    for i in range(len(m)):   
        for j in range(len(m[0])):   
        transposed[j][i] = m[i][j]
    return transposed  

def uppercaserandomarray(arr):   
    r = Random()   
    i = r.Next(len(arr))   
    for j in range(len(arr[i])):
        arr[i][j] = arr[i][j].upper()

def printarray(arr):
    print '\nPrint Array Content ' + arr.GetType().Name.Replace(']', str(len(arr)) + ']')
    for i in range(len(arr)):   
        print ' array [{0:2}'.format(i) + '] = {0:2}'.format(arr[i])

def printmatrix(m):   
    print '\nPrint Matrix Content ' + m.GetType().Name + '[' + str(len(m)) + ',' + str(len(m[0])) + ']'
    for i in range(len(m)):   
        for j in range(len(m[0])):   
            print ' array [{0:2},{1:2}] = {2:2} '.format(i, j, m[i][j])

def graphjaggedarray(arr):   
    '''When using Arrays, we can use for(each) instead of for by index:
    for s as (string) in arr:  
        for w as string in s: 
    ''' 
    print '\nPrint Text Content ' + arr.GetType().Name  
    for i in range(len(arr)):   
        line = ''
        line += 'Line{0:2}|'.format(i+1)
        for j in range(len(arr[i])):   
            line += '{0:3}'.format('*')   
        line += '(' + str(len(arr[i])) + ')'
        print line
        

def printjaggedarray(arr):
    print '\nPrint Jagged Array Content ' + arr.GetType().Name
    for i in range(len(arr)):
        line = ''
        for j in range(len(arr[i])):      
            line += ' ' + arr[i][j]
        if line == line.upper():
            line += ' <-- [UPPERCASED]'
        print line

def printcommonarrayexceptions(arr):
    try:
        arr[100][100] = 'hola'     
    except System.Exception as ex:
        print '\nException: \n%s\n%s' % (ex.GetType().Name, ex.Message)
    #except:
    #else:

def printtitle(message):    
    print ''  
    print '=' * 54   
    print message   
    print '=' * 54 


class Alphabet:
    # Array Field   
    _letters = []
    
    # Indexer Get/Set Property
    def __getitem__(self, idx):
        return self._letters[idx]
    def __setitem__(self, idx, value):
        self._letters[idx] = str(value).upper()
    
    # Read-Only Property
    def get_Length(self):
        return len(self._letters)   
    Length = property(fget=get_Length)

    # Constructor
    def __init__(self, param=None):           
        if type(param) == type(1):
            self._letters = list(' ' * param)
        elif type(param) == type(''):
            self._letters = list(str(param).upper())
        elif type(param) == type([]):
            self._letters = param
        else:
            self._letters = None

    # Overridden Method    
    def __str__(self):
        return ','.join(self._letters)

    # Method   
    def slice(self, start, length):
        return self._letters[start:start+length]

if __name__ == '__main__':
    main()


The output:






















































































Voilà, that's it. Next post in the following days.

Saturday, February 22, 2014

Arrays and Indexers in Zonnon



Today's post is about Arrays and Indexers in Zonnon. Here below you will find a very easy to follow program, that demonstrate arrays and indexer, by implementing some simple tasks that will make you grasp the idea of those 2 features real quick. The main goal of this post, is not really teaching arrays because, come on, you probably already know "all" about them, in fact, it is more to show you how you do that in Zonnon, in this case, compared to all other 22 languages on future posts, which essentially, is the real aim behind this blog.

By the way, if you missed my most recent post, "New Series - Arrays and Indexers", check it out. It has more details about the following program, and a bunch of definitions for the concepts used on this, and the following, posts. Or you can check my previous posts about arrays in C# and Oxygene just to compare.

I encourage you to copy the code below and try it yourself, normally, all programs you find in this blog are source code complete, just paste it on Zonnon Builder and run it.

Last thing. There is room for improvement of the code, using generics is one example, but Generics, Collections, lambdas, etc. will have their own "series" of posts.

(*****************************************
String Utilities Module
*****************************************)

module Str;

type {private} MArrayOfChar = array {math} * of char;
type {private} ArrayOfChar = array * of char;
type {private} ArrayOfString = array * of string;

procedure {public} CountWords(s: array * of char; sep: char): integer;
var i,slen,wlen,c: integer;
begin
  slen := len(s)-1;
  c := 0;
  for i := 0 to slen do
 wlen := 0;
 while (i < slen) & (s[i] # sep) do inc(wlen); inc(i); end;
 if (i <= slen) & (wlen > 0) then inc(c) end; 
  end;
  return c;
end CountWords;

procedure {public} Split(s: string; sep: char)
 : array * of string;
var i,j,k,slen,wlen,pos: integer;
 l: array * of char;
 a: array * of string;
begin
  l := new ArrayOfChar(len(s)+1);
  copy(s, l);
  slen := len(l)-1;
  a := new ArrayOfString(CountWords(l,sep));
  pos := 0; k := 0;
  for i := 0 to slen do
 wlen := 0;
 while (i < slen) & (l[i] # sep) do inc(wlen); inc(i); end;
 if (i <= slen) & (wlen > 0) then 
   if (i <= slen) then a[k] := s.Substring(pos,wlen); inc(k) end;
   for j := 0 to wlen do inc(pos) end;
 end; 
  end;
  return a;
end Split;

procedure {public} Join(c: char; arr: array {math} * of char): string;
var i: integer;
 s: string;
begin
  s := "";
  for i := 0 to len(arr) - 1 do
    s := s + string(arr[i]) + string(c);
  end;
  if len(s) == 0 then return s end;
  return s.Substring(0,s.LastIndexOf(c));
end Join;

end Str.

(*****************************************
Alphabet Object
*****************************************)

object {ref} Alphabet(asize: integer; astr: string; achar: array * of char) 
 implements [];

import Str;

type {private} ArrayOfChar = array * of char;
type {private} ArrayOfString = array * of string;

(* Array Field *) 
var {private} letters: array {math} * of char;  

(* Indexer Get/Set Property *)
procedure {public} Get(i: integer): char implements [].Get;
begin 
  return self.letters[i];
end Get;
procedure {public} Set(i: integer; c: char) implements [].Set;
var s: string;
begin
  s := string(c); 
  if ~(s = s.ToUpper()) then s := s.ToUpper(); c := s[0] end;
  self.letters[i] := c; 
end Set;

(* No Property, Getter instead *)
procedure {public} GetLength: integer; 
begin 
  return len(self.letters); 
end GetLength;  

(* Override Method *)
procedure {public} ToString: string implements System.Object.ToString;
begin
  return Str.Join(char(','), self.letters);
end ToString;

(* Method *)
procedure {public} Slice(start: integer; length: integer)
  : array  * of char;
var l: integer;
 a: array  * of char;
begin
  a := new ArrayOfChar(len(self.letters));
  a := self.letters[start..length-1];
  return a;
end Slice;

(* No Overloaded Constructors Support in v 1.3.0 *)
(* Contructor | Initializer *) 
begin   
  if asize # 0 then
    self.letters := new ArrayOfChar(asize);
  elsif astr # nil then
    self.letters := new ArrayOfChar(len(astr));
    copy(astr.ToUpper(),self.letters);
  elsif achar # nil then
    self.letters := achar;
  else
    self.letters := new ArrayOfChar(0);  
  end;  
end Alphabet.


(*****************************************
Program Module
*****************************************)

module Main;  
import System.Random as Random,
 Str, Alphabet;

type {private} ArrayOfChar = array * of char;
type {private} ArrayOfString = array * of string;
type {private} ArrayMatrix = array {math} *,* of integer;
type {private} JaggedArrayOfString = array * of array * of string;


procedure ReverseChar(var arr: array * of char)
 : array * of char;
var 
  reversed: array * of char; 
  i,j: integer;
begin
  i := 0;
  reversed := new ArrayOfChar(len(arr));
  for j := len(arr,0)-1 to 0 by -1 do  
    reversed[i] := arr[j];  
    inc(i);
  end;
  return reversed;
end ReverseChar;

procedure BubbleSortInt(var arr: array {math} * of integer)
 : array {math} * of integer;   
var i, j, swap: integer;  
begin  
  swap := 0;  
  for i := len(arr) - 1 to 1 by -1 do  
    for j := 0 to i - 1 do  
      if arr[j] > arr[j + 1] then  
        swap := arr[j];    
        arr[j] := arr[j + 1];    
        arr[j + 1] := swap;   
      end;  
    end;  
  end;  
  return arr;  
end BubbleSortInt;  

procedure BubbleSortString(var arr: array * of string)
 : array * of string;   
var 
  i, j: integer;  
  swap: string;
begin  
  swap := "";  
  for i := len(arr) - 1 to 1 by -1 do  
    for j := 0 to i - 1 do  
      if arr[j,0] > arr[j + 1,0] then  
        swap := arr[j];    
        arr[j] := arr[j + 1];    
        arr[j + 1] := swap;   
      end;  
    end;  
  end;  
  return arr;  
end BubbleSortString; 

procedure TransposeMatrix(m: array {math} *,* of integer)
 : array {math} *,* of integer;  
var   
  i, j: integer;
  transposed: array {math} *,* of integer;    
begin  
  (* Transposing a Matrix 2,3   
   *   
   * A =  [6  4 24]T [ 6  1]   
   *      [1 -9  8]  [ 4 -9]  
   *                 [24  8]  
   *)    
  transposed := new ArrayMatrix(len(m, 1), len(m, 0));
  for i := 0 to len(m,0) - 1 do 
    for j := 0 to len(m,1) - 1 do 
      transposed[j, i] := m[i, j];    
    end;  
  end;  
  return transposed;  
end TransposeMatrix;  

procedure UpperCaseRandomArray(arr: array * of array * of string); 
var r: Random; 
 i,j: integer;
 s: string; 
begin 
  r := new Random; 
  i := r.Next(0, len(arr) - 1); 
  for j := 0 to len(arr[i]) - 1 do 
 s := arr[i,j];
    arr[i,j] := s.ToUpper();
  end; 
end UpperCaseRandomArray; 

procedure PrintArrayChar(var arr: array * of char);
begin
  writeln("Print Array Content Char[":0,string(len(arr)):0,"]":0);
  for i := 0 to len(arr, 0) - 1 do
    writeln(" array [",i:2,"] = ",arr[i]:2," ");
  end;
  writeln;
end PrintArrayChar;

procedure PrintArrayInt(var arr: array {math} * of integer);
begin
  writeln("Print Array Content Int32[":0, string(len(arr)):0, "]":0);
  for i := 0 to len(arr, 0) - 1 do
    writeln(" array [",i:2,"] = ",arr[i]:2," ");
  end;
  writeln;
end PrintArrayInt;

procedure PrintArrayString(var arr: array * of string);
begin
  writeln("Print Array Content String[":0, string(len(arr)):0, "]":0);
  for i := 0 to len(arr, 0) - 1 do
    writeln(" array [",i:2,"] = ",arr[i]:2," ");
  end;
  writeln;
end PrintArrayString;

procedure PrintMatrix(m: array {math} *,* of integer);   
var i,j: integer;
begin  
  writeln("Print Matrix Content Int32[":0, string(len(m,0)):0, ",":0, string(len(m,1)):0, "]":0); 
  
  for i := 0 to len(m,0) - 1 do 
    for j := 0 to len(m,1) - 1 do  
   writeln(" array [":0,i:2,j:2,"] = ",m[i, j]:2," ":0);
    end;  
  end;   
  writeln;
end PrintMatrix;  

procedure GraphJaggedArray(arr: array * of array * of string); 
var lineCount: integer; 
 i,j: integer;
begin
  writeln;
  writeln("Print Text Content String[][]":0); 
  lineCount := 1; 
  for i := 0 to len(arr) - 1 do 
    write("Line":0,lineCount:2,"|":0); 
 for j := 0 to len(arr[i]) - 1 do 
      write("*":3);
    end; 
    writeln(" (":0,string(len(arr[i])):0,")":0); 
    inc(lineCount);
  end; 
  writeln;
end GraphJaggedArray; 

procedure PrintJaggedArray(arr: array * of array * of string); 
var i,j: integer;
 line: string; 
 linearr: array * of string;
begin 
  writeln;
  writeln("Print Jagged Array Content String[][]":0); 
  for i := 0 to len(arr) - 1 do 
    line := "";
    for j := 0 to len(arr[i]) - 1 do 
      line := line + " " + arr[i,j];   
    end; 
    if line = line.ToUpper() then 
   line := line + " <-- [UPPERCASED]"; 
    end; 
    writeln(line:0);
  end; 
end PrintJaggedArray; 

procedure PrintCommonArrayExceptions(arr: array * of array * of string); 
(* 
"Extra information about the exception can be accessed 
by calling the predefined function 'reason'. This causes the 
runtime system to return a string which explains the reason 
for the exception." Not working in Zonnon version 1.3.0
var s: string;
do ... on exception do
s := reason; <- This gives a "reason not declared" error at compile time.
end; 
*)
begin 
  do 
    arr[100,100] := 'hola'; 
  on NilReference do
    writeln;
    writeln("Exception: NilReference":0);
  on OutOfRange do
    writeln;
    writeln("Exception: OutOfRange":0);
  on exception do  
    writeln;
    writeln("Exception: Other":0); 
  on termination do
    (* nothing *)
  end; 
  writeln;
end PrintCommonArrayExceptions; 

procedure PrintTitle(message: string);   
begin  
  writeln('======================================================':0);
  writeln(message:0);
  writeln('======================================================':0);
  writeln;
end PrintTitle;  

var
(*writeln(pos,wlen,Substring(s,pos,wlen),s.Substring(pos,wlen));*)
  i: integer;
  (* Declare Array of Chars *)
  letters: array 5 of char;
  inverse_letters: array * of char;

  (* Mathematical extensions
  Mathematical extensions of Zonnon let use arrays in a more convenient way 
  for writing applications where multidimensional algebra is used. 
  Arrays to be used in mathematical extensions should be defined with special
  {math} modifier. ArrayType = array "{" math "}" Length {"," Length} of Type.
  This option allow you to initialize math array with array expressions, 
  but it only works for numerical arrays such as 
  array {math} of integer | real | boolean but not of string.
  *)

  (* Declare Array of Integers *)
  numbers, ordered_numbers: array {math} * of integer;
  (* Declare Array of Strings *)
  names: array 5 of string;
  ordered_names: array * of string;
  (* Declare multi-dimensional Array *)
  matrix: array {math} 2, 3 of integer;
  transposed_matrix: array {math} *,* of integer;
  (* Declare Jagged Array *)
  text: array * of array * of string;
  (* Indexer *)
  vowels,en,na: Alphabet;
  vs,w: array {math} * of char;
  word1,word2,word3: string;
begin  
  (* Single-dimensional Array(s) *)
  PrintTitle("Reverse Array Elements"); 

  (* Initialize Array of Chars  *)
  letters[0] := 'A';
  letters[1] := 'E';  
  letters[2] := 'I';  
  letters[3] := 'O';  
  letters[4] := 'U'; 

  PrintArrayChar(letters);   
  inverse_letters := ReverseChar(letters);    
  PrintArrayChar(inverse_letters); 
  
  PrintTitle("Sort Integer Array Elements");  

  (* Initialize Math Array of Integers *)
  numbers := [ 10, 8, 3, 1, 5];    
  PrintArrayInt(numbers);
  ordered_numbers := BubbleSortInt(numbers);    
  PrintArrayInt(ordered_numbers);
  
  PrintTitle("Sort String Array Elements");    
    
  (* Initialize Array of Strings *)
  names[0] := "Damian";     
  names[1] := "Rogelio"; 
  names[2] := "Carlos";     
  names[3] := "Luis";               
  names[4] := "Daniel";    
  PrintArrayString(names);  
  ordered_names := BubbleSortString(names);     
  PrintArrayString(ordered_names);

  (* Multi-dimensional Array (Matrix row,column) *)
    
  PrintTitle("Transpose Matrix");    
    
  (* Matrix row=2,col=3  
   * A =  [6  4 24]  
   *      [1 -9  8]  
  *)    
  (* Array inline expression used to declare and initialize array *)
  matrix := [[6, 4, 24], 
    [1, -9, 8]];   

  PrintMatrix(matrix);    
  transposed_matrix := TransposeMatrix(matrix);    
  PrintMatrix(transposed_matrix);
  
  (* Jagged Array (Array-of-Arrays) *)
    
  PrintTitle("Upper Case Random Array & Graph Number of Elements");
  
  (*
  * Creating an array of System.String arrays using the (System.)String.Split method
  *
  * Text extract from: 'El ingenioso hidalgo don Quijote de la Mancha'  
  *   
  *)
  text := new JaggedArrayOfString(8,0);
  text[0] := Str.Split("Hoy es el di­a mas hermoso de nuestra vida, querido Sancho;", ' ');
  text[1] := Str.Split("los obstaculos mas grandes, nuestras propias indecisiones;", ' ');
  text[2] := Str.Split("nuestro enemigo mas fuerte, miedo al poderoso y nosotros mismos;", ' ');
  text[3] := Str.Split("la cosa mas facil, equivocarnos;", ' ');
  text[4] := Str.Split("la mas destructiva, la mentira y el egoi­smo;", ' ');
  text[5] := Str.Split("la peor derrota, el desaliento;", ' ');
  text[6] := Str.Split("los defectos mas peligrosos, la soberbia y el rencor;", ' ');
  text[7] := Str.Split("las sensaciones mas gratas, la buena conciencia...", ' ');

  PrintJaggedArray(text);
  UpperCaseRandomArray(text); 
  PrintJaggedArray(text); 
  GraphJaggedArray(text);

  (* Array Exceptions *)

  PrintTitle("Common Array Exceptions"); 

  PrintCommonArrayExceptions(nil); 
  PrintCommonArrayExceptions(text);  

  (* Accessing Class Array Elements through Indexer *) 

  PrintTitle("Alphabets"); 

  vowels := new Alphabet(5,nil,nil); 
  vowels[0] := char('a'); 
  vowels[1] := char('e'); 
  vowels[2] := char('i'); 
  vowels[3] := char('o'); 
  vowels[4] := char('u');

  vs := new ArrayOfChar(5);
  vs[0] := vowels[0]; vs[1] := vowels[1]; 
  vs[2] := vowels[2]; vs[3] := vowels[3]; 
  vs[4] := vowels[4];
  
  writeln;
  writeln("Vowels = {":0, Str.Join(',', vs):0, "}":0);

  en := new Alphabet(0,'abcdefghijklmnopqrstuvwxyz',nil);
  writeln("English Alphabet = {":0,en.ToString(),"}":0);  
  
  na := new Alphabet(0,nil,en.Slice(9, 19));
  writeln("Alphabet Extract en[9..19] = {":0,na.ToString():0,"}":0);             

  w := new ArrayOfChar(5); 
  w[0] := en[6]; w[1] := en[14]; w[2] := en[14]; w[3] := en[3];
  copy(w, word1);

  w := new ArrayOfChar(4); 
  w[0] := en[1]; w[1] := en[24]; w[2] := en[4];
  copy(w, word2);
  
  w := new ArrayOfChar(9); 
  w[0] := en[4]; w[1] := en[21]; w[2] := en[4]; w[3] := en[17]; 
  w[4] := en[24]; w[5] := en[14]; w[6] := en[13]; w[7] := en[4];
  copy(w, word3);

  writeln;
  writeln(word1:0, " ":0, word2:0, ", ":0, word3:0, "!":0); 
  writeln;

  readln; 
end Main.


The output:






















































































Voilà, that's it. Next post in the following days.