This site is updated infrequently. For up-to-date information, please visit the new OCaml website at ocaml.org.

Re: native code compiler and exceptions
• Jocelyn Serot
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 1996-09-27 (15:57) From: Jocelyn Serot Subject: Re: native code compiler and exceptions
```
In his answer to my original question, P. Weis (Pierre.Weis@inria.fr) says:

> Wao! To ``rely heavily on array bounds violation'' is a very ugly style
> of programming. I could not imagine why you need to use this style.

Well, maybe the formulation ``rely heavily on array bounds violation'' was
a bit misleading. My code relies on the correct handling of exceptions that,
at the lowest level may be trapped as array bound violation.
I will try yo explain my pb on a small example.
Suppose that images are represented as pixel 2d-arrays (in fact, images
are implemented as ADTs, with their internal representation hidden).

# type image = int array array
# let get_pixel i y x = i.(y).(x)
# let set_pixel i y x p = i.(y).(x) <- p
# let create nr nc = Array.new_matrix nr nc 0

What i want to do is to compute, for example is a simple 2d-convolution,
turning pixel(x,y) into (p(x-1,y)+p(x,y-1)+p(x+1,y)+p(x,y+1))/4.
A possible manner to handle the clipping effect at image boundaries is to
set that p(x,y) = 0 whenever x<0 ot y<0.
So it does not seem to me so "ugly" to write my convolution fn like that:

# let conv im =
#    let nr = nb_rows im and nc = nb_cols im in
#    let im' = create nr nc in
#    for y = 0 to pred nr do for x = 0 to pred nc do
#		let p1 = try_get_pixel im (x-1) y 0 in
#		let p2 = try_get_pixel im x (y-1) 0 in
#		let p3 = try_get_pixel im (x+1) y 0 in
#		let p4 = try_get_pixel im x (y+1) 0 in
#        set_pixel im' (y,x) ((p1+p2+p3+p4)/4) done done;
#    m'

making use of the given access fn:

# let try_get_pixel im y x clip =
#    try get_pixel im y x with Invalid_argument _  -> clip

(btw, note that is this case clip might be a _fn_ of the "faulty" coordinates,
like:

# let try_get_pixel im y x clip =
#    try get_pixel im y x with Invalid_argument _  -> clip y x
)

Is this not "good" fnal programming style ?..
Or does the "ugliness" lies only in the [... with Invalid_argument _  ->...]
construct ? In this case, i guess i should test _explicitely_ whether (y,x) are
in bounds instead of relying of the exception [Invalid_argument "Array.get"].Ie:

# let try_get_pixel im y x clip =
#    if (y<0 || y>=(nb_rows im) || x<0 || x>=(nb_cols im)) then clip
#    else get_pixel im y x

Is it what you mean ?

Jocelyn
--
E-mail: Jocelyn.Serot@lasmea.univ-bpclermont.fr .............................
S-mail: LASMEA - URA 1793 CNRS, Universite Blaise Pascal, 63177 Aubiere cedex
Tel: (33) 73.40.73.30 - Fax: (33) 73.40.72.62 ...............................
.... http://wwwlasmea.univ-bpclermont.fr/Personnel/Jocelyn.Serot/Welcome.html

```