Programming: The Elements of HicEst

Programming elements like structure, procedures, specifications, expressions, assignments, execution control, loops, jumps, errors, debugging.

• program_structure
  : HicEst does not force a special structure, but the following program design is recommended:
  1. main_program
     • start at top of script, no special marker statement, script is free format, maximum line length 253 characters
     • specifications
     • expressions and assignments
     • • END ! terminate the main program
  2. DATATYPES
     • undeclared: 8-byte floating point scalar
     • declared: ⇾ arrays, strings, fuzzy
  3. SUBROUTINE or FUNCTION
     procedures
     (optional, not nested, after main program)
     1. with procedure arguments, or with USE: all names local, except header and USE arguments
        • • SUBROUTINE subname(arg1, arg2, ...)
        • • FUNCTION funcname(arg1, arg2, ...)
        • • DIMENSION argN1, argN2, ... ! (automatic lengths)
        • • CHARACTER argS1, argS2, ... ! (automatic lengths)
     2. SUBROUTINE header with neither optional arguments, nor with USE:
        • SUBROUTINE subname ! all names are global
     3. use
        : ⇾ optional reference to main or other procedure names
        • • USE : main_name1, main_name2, ...
          • USE other_procedure: other_procedure_name1, other_procedure_name2, ...
     4. specifications
     5. ⇾ expression and assignments, ⇾ execution control
     6. • END ! terminate the subroutine or function
  4. appendix
     ( ⇾ optional non-compiling section at end of script)
• specifications
  : define Strings and Arrays, everything else is implicitely 8-byte floating point numeric.
  • • CHARACTER OneByte, TenByte*10, FittedLength="Hello World", Initialized*100/"blank padded txt"/
  • • REAL :: elements=3, rows=4, columns=5, vector1(elements), matrix1(rows, columns), ...
    Conversions to integer are done automatically ( ⇾ how to store other binary formats)
  • • REAL, PARAMETER :: named_constant = 3.1415, ... ! invariable, set at compile time
  • • DIMENSION vector2(3), matrix2(rows, columns), ...
  • • DATA vector1/1,2,3/, matrix1(1,2, 3.1415, 4,5,6,7,8,9,10,11,12), ...
  • the ALIAS function allows to dynamically define or redefine substrings or subarrays (e.g. a matrix row)
  • the ALLOCATE function allows to dynamically increase the length of strings or arrays
• expressions_and_assignments

  character_strings	see CHARACTER for definitions
  text = "hello world"	string variable = string constant
  c100 = Left // Right	string concatenation appends Left to Right
  text(i: j) = string(3:)	substrings : text byte i to j = string byte 3 to end_string
  c1 = CHAR( 65 )	same as c1 = 'A'
  relational	compares a and b (both numeric, or both character)
  a < b	less than (same as a.LT.b). 3 < 4 evaluates to 1
  a <= b	less than or equal to (same as a.LE.b). "A" <= "a" evaluates to 1 (A precedes a in the ASCII collating sequence)
  a == b	equal to (same as a.EQ.b). 1-4 == (-3) evaluates to 1 (parenthesize unary subtraction)
  a /= b	not equal to (same as a.NE.b). 3 * 4 > 5 evaluates to 1 (numeric has higher precedence than relational)
  a >= b	greater than or equal to (same as a.GE.b). 3 >= 4 - 2 evaluates to 1
  a > b	greater than (same as a.GT.b). 'a' > 'a' // 'A' evaluates to 0 (// has higher precedence than relational)
  logical	0 is false, /=0 is true:
  true = -123.45	any scalar value not equal to 0 is true
  maybe = y > 1	maybe is set to 1 for y > 1, else it is 0
  (3 < 4) + 5	→ 6 ( because 3 < 4 → 1)
  L1 + L2	→ L1+L2 (false if 0)
  (L1>0) + (L2<0)	or , true if not 0
  (L1>0) * (L2<0)	and , true if not 0
  IF( x ) x = 1/x	conditional execution: division only for x not equal 0, ⇾ see also
  scalar_numeric	all numeric entities are 8 byte floating point
  3.1415	constant
  pi = 3.1415	defines a variable named pi
  pi = ACOS(-1)	set pi to result of arccosine function
  (3 + pi) / 2	parenthesis to force order of evaluation
  a = -1	unary subtraction
  b = 1 + 2 - 3/4	b is set to 2.25
  c = (2^2)**0.5	^ and ** are identical exponentiation operators
  i = INT( pi )	== 3 (i is internally still 8-byte floating point)
  L = LEN("Hello")	== 5
  operator_precedence :	(from low:) relational → + and - → * and / → ^ or ** (to high) 2^3 / 4 * 3 + 0.5 > 6 is the same as (((2^3) / 4 * 3) + 0.5) > 6
  array	⇾ array definitions
  vec(15)	element 15 of the 1-dimensional array vec. Index origin is 1.
  mtx(i,j)	element row i, column j. This is element number (i-1)*columns + j (storage is row by row).
  vec = (3.14, x, x+1, x^2, SIN(x), ...)	set vec to individual values starting with element 1
  mtx = 0	all elements of mtx = 0
  vec = $**2	set vec = 1 4 9 16 25 ...
  vec = mod( $,11)==1	set vec = (1 0 0 0 0 0 0 0 0 0 1 0 0 ...)
  ALLOCATE(vec, 10, 10)	set vec to a 10x10 unity_matrix
  DLG(Edit = matrix)	opens a spreadsheet-like dialog
  LINE(x=x_array, y=y_array)	plot one array against another
  DIFFEQ(..., Y=vector)	simultaneous 1st order differential equations
  INDEX( vector, 3.14 )	1st occurence of 3.14 in vector
  INTPOL(XV=x_vec, YV=y_array, x=3.27, ...)	cubic interpolation
  READ(text='3.1 by 5.2 and 4 4 U') vector	set vector = (3.1, 5.2, 4, 4)
  SOLVE(Matrix=A, Vector=B)	solve linear equations
  SORT(Vector=A, Sorted=B)	sort has many options
  WRITE(Name) vec	outputs e.g.: vec(1)=1 vec(2)=3.141592654 vec(3)=2.302

• execution_control
  • conditional_execution
    of a single statement ⇾ the If statement

    IF(expression) statement

    Conditionally executes one statement if expression evaluates to non-zero

  • conditionally execute blocks of statements ⇾ the If statement

    IF (expr1) THEN	1st statement of an IF construct
    true block	executed if expr1 is non-zero
    ELSEIF (expr2) THEN
    elseif block	executed if expr2 is non-zero
    ELSE
    else block	executed if expr1 == expr2 == 0 (false)
    ENDIF	terminates an IF construct

  • loop
    over a block of statements ( DO ... ENDDO)

    DO var=start,end[, stepsize]	1st statement of a DO/ ENDDO construct
    block of statements	looped over 1 + INT((end-start)/stepsize) times
    ENDDO	terminating statement of loop

  • loop over a block of statements ( DO label ... label CONTINUE)

    DO lbl var=start,end[, stepsize]	1st statement of a labeled DO construct
    block of statements	looped over 1 + INT((end-start)/stepsize) times
    lbl CONTINUE	terminating statement of a labeled DO loop

  • inline_loop
    loop in a single statement, see InlineLoop

    result = op(expression)	expression is array or character
    factorial = *(1:10)	factorial = 1*2*3*4*5*6*7*8*9*10
    trace = +( mtx( $1, $1) )	$1 is the loop index of the inline loop

  • label
    : For good programming style labels should be avoided as much as possible. Labels can be helpful to handle error conditions. HicEst is very forgiving in the use of labels, you may even jump into loops or IF constructs, be careful.

    123	the label 123 starts this line

  • jump
    to a labeled statement

    GOTO 123

    jump to the statement that begins with the label 123

  • on_error_jump
    to a labeled statement

    LOG(x, *999)	jump to the statement labeled 999 if x is ≤ 0
    READ(File=test, ERror=999)	on error jump to statement label 999 most functions with optional keywords have the ERror keyword

• debugging

  statement	use any output method
  xy	shows current value of xy at line end when executed in single step (↵ or Ctrl+S or toolbar step tool) or trace mode (Ctrl+T or toolbar trace tool)
  F1 or right mouse click on xy	opens edit dialog for xy. The dialog links to the break-on-change-dialog
  F1 or right mouse click on whitespace	opens the break_on_change_dialog
  WRITE(StatusBar, Name) xy	⇾ trace output to status bar, program continues
  IF(xy > yz) DLG(Edit=xy, Text=yz)	dialog box break point, program stops
  WRITE(Message=...) xy	⇾ message box break point, program stops
  IF(xy > 3.1) BEEP(1)	beeps warnings or tunes