Re: Alternatives to C: ObjectPascal, Eiffel, Ada or Modula-3?

[frankenstein <klohmuschel@yahoo.de>]

As an addendum: I shall post in the following some bits of my matrix
class. Sorry there are no comments and it lacks all my pretty
printing, slicing and mapping over matrix stuff. However, you should
get an idea. Scroll down until you reach the example of the matrix
matrix multiplication. If you want to bench it againts a C code: use
google for the C code of a matrix matrix multiplication:

copy the code enclosed into a file e.g. foo.scm

and on the command line: bigloo -Obench foo.scm, and time a.out. If
you want to increase the size use 1024 e.g. in (do-main 1024).

Some basics to the class: read through it and you will encounter 3
classes: 64-bit, 32-bit and realmat

you create an n-dimensioanal matrix as follows: (mk-f64mat i j ... n
val: 0.0e0)
you access the values: (f64m& i j ... n)
you store values: (f64m! i j ... n value)

same goes for f32, and realmat. update and accessing is done by the
macro and should be sufficient fast.

Raueber Hotzenplotz


==
(module matrix
   (export
    (class f64mat
       mat
       (rank::bint (default 1))
       (dims::pair-nil (default '(1)))
       (print-index?::bool (default #t)))
    (class f32mat
       mat
       (rank::bint (default 1))
       (dims::pair-nil (default '(1)))
       (print-index?::bool (default #t)))
    (class realmat
       mat
       (rank::bint (default 1))
       (dims::pair-nil (default '(1)))
       (print-index?::bool (default #t)))
    (inline make-matrix::obj  op::pair-nil #!key   (val 0.0e0) (type
(lambda (x y) (make-vector x y))))
     (inline make-matrix-local::obj  op::pair-nil  #!key (val 0.0e0)
(type (lambda (x y) (make-vector x y))))
    (inline mk-f64mat::f64mat  #!rest op::pair-nil #!key (val 0.0e0))
    (inline mk-f32mat::f32mat  #!rest op::pair-nil #!key (val 0.0))
    (inline mk-realmat::realmat #!rest  op::pair-nil #!key (val 0.0))
    (macro aref-set-helper fun::obj x::obj i::bint  .  op::obj)
    (macro f64m&  mat::f64mat . op::obj)
    (macro f32m& mat::f32mat . op::obj)
    (macro realm& mat::realmat . op::obj)
    (macro f64m!c  mat::f64mat val::double . op::obj)
    (macro f64m!  mat::f64mat  . op::obj)
    (macro f32m!c  mat::f32mat val::real . op::obj)
    (macro f32m!  mat::f32mat val::real . op::obj)
    (macro realm!c  mat::realmat val::real . op::obj)
    (macro realm!  mat::realmat val::real . op::obj)))




(define-inline (.1st. x::pair-nil) (car x))
(define-inline (.2nd. x::pair-nil) (cadr x))
(define-inline (.3rd. x::pair-nil) (caddr  x))



(define-inline (make-matrix-local::obj  op::pair-nil
				  #!key (val 0.0e0)
				  (type (lambda (x y) (make-vector x y))))
   (if (=fx 1 (length op))
       (type (car op) val)
       (let ([mx::vector (make-vector (car op))])
	  (do [(oi 0 (+fx oi 1))]
	      [(=fx oi (car op))]
	      (vector-set! mx oi (make-matrix-local  (cdr op) val: val type:
type)))
	  mx)))



(define-inline (make-matrix::obj  op::pair-nil
				  #!key (val 0.0e0)
				  (type (lambda (x y) (make-vector x y))))
   (if (=fx 1 (length op))
       (type (car op) val)
       (let ([mx::vector (make-vector (car op))])
	  (do [(oi 0 (+fx oi 1))]
	      [(=fx oi (car op))]
	      (vector-set! mx oi (make-matrix  (cdr op) val: val type:
type)))
	  mx)))





(define-inline (mk-f64mat::f64mat  #!rest  op::pair-nil #!key (val
0.0e0))
   (let* ((indx::bint (-fx (length op) 1)))
      (if (<fx indx 2)
	  (begin
	     (error "mk-f64mat in matrix.scm" "you would have to pass at
least 1 dimension"  op))
	  (begin
	     (let* ((val::double (list-ref op indx))
		    (op::pair (take op (-fx indx 1))))
		;(print op val indx)
		(instantiate::f64mat (mat (make-matrix-local op val:  val type:
(lambda (x y) (make-f64vector x y))))
				     (rank (length op))
				     (dims op)))))))


(define-inline (mk-f64matr::f64mat  #!rest op::obj)
   (instantiate::f64mat (mat (make-matrix-local op val:  0.0e0 type:
(lambda (x y) (make-f64vector x y))))
			(rank (length op))
			(dims op)))



(define-inline (mk-f32matr::f32mat  #!rest op::obj)
   (instantiate::f32mat (mat (make-matrix-local op val: 0.0 type:
(lambda (x y) (make-f32vector x y))))
			(rank (length op))
			(dims op)))



(define-inline (mk-f32mat::f32mat  #!rest  op::pair-nil #!key (val
0.0))
   (let* ((indx::bint (-fx (length op) 1)))
      (if (<fx indx 2)
	  (begin
	     (error "mk-f32mat in matrix.scm" "you would have to pass at
least 1 dimension"  op))
	  (begin
	     (let* ((val (list-ref op indx))
		    (op::pair (take op (-fx indx 1))))
		(instantiate::f32mat (mat (make-matrix-local op val:  val type:
(lambda (x y) (make-f32vector x y))))
				     (rank (length op))
				     (dims op)))))))



(define-inline (mk-realmatr::realmat  #!rest op::obj)
   (instantiate::realmat (mat (make-matrix-local op val: 0.0 type:
(lambda (x y) (make-vector x y))))
			 (rank (length op))
			 (dims op)))


(define-inline (mk-realmat::realmat  #!rest  op::pair-nil #!key (val
0.0))
   (let* ((indx::bint (-fx (length op) 1)))
      (if (<fx indx 2)
	  (begin
	     (error "mk-realmat in matrix.scm" "you would have to pass at
least 1 dimension"  op))
	  (begin
	     (let* ((val::double (list-ref op indx))
		    (op::pair (take op (-fx indx 1))))
		(instantiate::realmat (mat (make-matrix-local op val:  val type:
(lambda (x y) (make-vector x y))))
				     (rank (length op))
				     (dims op)))))))





(define-macro (m& x::obj i::bint  .  op::obj)
   (if (null? op)
       `(vector-ref ,x ,i)
       `(a& (vector-ref ,x ,i)  ,@op)))


(define-macro (m!  x::obj val::obj i::bint  .  op::obj)
   (if (null? op)
       `(vector-set! ,x ,i ,val)
       `(a! (vector-ref ,x ,i)  ,@op)))



(define-macro (f64m&  mat::f64mat . op::obj)
   `(with-access::f64mat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (f64vector-ref xx yy))
			mat   ,@op)))


(define-macro (f32m&  mat::f32mat . op::obj)
   `(with-access::f32mat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (f32vector-ref xx yy))
			mat   ,@op)))

(define-macro (realm&  mat::realmat . op::obj)
   `(with-access::realmat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (vector-ref xx yy))
			mat   ,@op)))




(define-macro (f64m!  mat::f64mat  . op::obj)
   (let* ((indx::bint (-fx (length op) 1))
	  (val::double (list-ref op indx))
	  (op::pair (take op indx)))
      `(with-access::f64mat ,mat (mat)
	  (aref-set-helper (lambda (xx yy) (f64vector-set! xx yy ,val))
			   mat   ,@op))))


(define-macro (f32m!  mat::f32mat  . op::obj)
   (let* ((indx::bint (-fx (length op) 1))
	  (val::double (list-ref op indx))
	  (op::pair (take op indx)))
      `(with-access::f32mat ,mat (mat)
	  (aref-set-helper (lambda (xx yy) (f32vector-set! xx yy ,val))
			   mat   ,@op))))


(define-macro (realm!  mat::realmat  . op::obj)
   (let* ((indx::bint (-fx (length op) 1))
	  (val::double (list-ref op indx))
	  (op::pair (take op indx)))
      `(with-access::realmat ,mat (mat)
	  (aref-set-helper (lambda (xx yy) (vector-set! xx yy ,val))
			   mat   ,@op))))


(define-inline (aref-set-helper-new fun::obj x::obj i::bint   op::obj)
   (if (null? op)
       (fun x i)
       (aref-set-helper-new fun (vector-ref x i)  (car op) (cdr op))))


(define-macro (aref-set-helper fun::obj x::obj i::bint  .  op::obj)
   (if (null? op)
       `(,fun ,x ,i)
       `(aref-set-helper ,fun (vector-ref ,x ,i)  ,@op)))






(define-macro (f64m!c  mat::f64mat val::double . op::obj)
   `(with-access::f64mat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (f64vector-set! xx yy ,val))
			mat   ,@op)))


(define-macro (f32m!c  mat::f32mat val::real . op)
   `(with-access::f32mat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (f32vector-set! xx
yy ,val)))))


(define-macro (realm!c  mat::realmat val::real . op::obj)
   `(with-access::realmat ,mat (mat)
       (aref-set-helper (lambda (xx yy) (vector-set! xx yy ,val))
			mat   ,@op)))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Test: matrix -matrix multiplication
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; we craete a matrix here:
;; (mk-f64mat rows cols val: 0.0e0)
;; will create a 64bit matrix of size (rows x cols)
;;
;; we can update individual values by:
;; (f64m! matrix i j value)
;; matrix is the matrix
;; i, j are the indices (based and rows runs first)
;; value is the value
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-inline (mkmatrix::f64mat rows::bint cols::bint)
   (let ((mx::f64mat (mk-f64mat  rows cols val: 0.0e0))
	 (count::double 0.5e0))
      (do ((i 0 (+fx i 1)))
	  ((=fx i rows))
	  (let ((row (make-f64vector cols 0.0e0)))
	     (do ((j 0 (+fx j 1)))
		 ((=fx j cols))
		 (f64m! mx i j count)
		 (set! count (+fl count 0.5)))))
      mx))




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; we do the matrix matrix multiplication
;;
;; we cann access values in the matrix class by:
;; (f64m& matrix i j)
;; and we set values by: (f64m! matrix i j value)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-inline (mmult::f64mat rows::bint cols::bint m1::f64mat
m2::f64mat)
   (let ((m3::f64mat (mk-f64mat  rows cols val: 0.0e0)))
      (do ((i 0 (+fx 1 i)))
	  ((=fx i rows))
	  (do ((j 0 (+fx 1 j)))
	      ((=fx j cols))
	      (let ((val::double 0.0e0))
		 (do ((k 0 (+fx 1 k)))
		     ((=fx k cols))
		     (set! val (+fl val
				    (*fl (f64m& m1 i k)
					 (f64m& m2  k j)))))
		 (f64m! m3  i j val))))
      m3))




(define (do-main size::bint)
   (let ((mm::double 0.0e0)
	 (m1::f64mat (mkmatrix  size size))
	 (m2::f64mat (mkmatrix size size)))
      (set! mm (mmult size size m1 m2))
      (let ((r0 (vector-ref (f64mat-mat mm) 0)))
	 (print (f64vector-ref r0 0)))))


(do-main 512)
==

On Aug 1, 8:46 pm, frankenstein <klohmusc...@yahoo.de> wrote:
> On Jul 29, 12:14 am, Jon Harrop <j...@ffconsultancy.com> wrote:
>
> > fft1976 wrote:
> > If you're using VS then I highly recommend F# for numerical work, largely
> > because it makes parallelism so easy.
>
> > > Gambit-C Scheme (one of the best of LISPs, IMO): about 2x slower than
> > > C (single core only), but you have to work to get within 2x (unlike
> > > OCaml), and if you want it fast, it can't be safe (switch controlled).
>
> > Bigloo?
>
> Bigloo is a good option for numerical work and sometimes beats my
> Fortran F90 code. I am not a Fortran 90 expert but that Bigloo stacks
> up  well compared to Fortran tells a lot.
>
> Fact #1: We must forget about the language shootout page because it is
> and always has been a kinda like of Micky Mouse benchmark (any idot
> who thought he might make up for an excellent programmer posted crappy
> code and once posted it is forever in google's history and a lot of
> other idiots will use the result from the benchmark). RIP language
> shotout page.
>
> Fact 2: The performance of Bigloo especillay for larger problems where
> your simulations will consume 12 hours and more on processor times and
> will use 2GB of associated main memory and more  does not come for
> free. You will have to program your intended code with this in mind.
> HOWEVER, turning Bigloo into a numerical powerhorse for large data
> simulations is straightforward:
>
> a) use from the very beginning on *fx, *fl ... native Bigloo operators
> (IT IS VERY easy to use them and the compiler will help you out a lot
> to spotting type mismatches; however, you won't have to use your gun
> as you likely would by using OCaml and shooting yourself to stop the
> battling for types).
>
> b) use f32 or f64 arrays (I created my own array class) whenever
> possible. especially use f32 for large data simulations since it makes
> a whole lot of a difference if your data are half the size in the main
> memory in 32-bits mode than as it would be in 64-bits even though
> internal calculations are always automatically casted to Bigloo its C
> type double.
>
> c) use classes to make code clearer: classes are very fast in Bigloo.
>
> d) whenever you have to read in binary data (note there are some
> issues with f32 bits; read Bigloo its mailing list) use or check for
> the following undocumented functions and your code will fly: (ieee-
> string->double), (ieee-string->float), (double->ieee-string), (float-
>
> >ieee-string), etc.
>
> e) use -Obench option when compiling, -Obench covers more or less all
> Bigloo to C related and associated compiler options with speed in mind
> (no bound checking etc.).
>
> f) add types to your code to make it readable for others and for your
> pleasure to read and understand your own code during your debugging
> excercise:
>
> ==
> (define (add-vector::vector vec1::vector vec2::vector name::bstring
> x::bint y::my-class)
>   (...))
> ==
>
> I haven't realaesed it yet but I have fully fledged with a whole lot
> of bells and whistles bindings to:
>
> - full clapack (linear algebra package converted from Fortran to C by
> f2c freely downloadable from the net)
> - full DISLIN (high level plotting routine)
> - binding to a random number generator
> - binding to a mie scattering code
> - a matrix class (for creating n dimensional f32 and f64 matrices,
> mapping over n-dimensional matrices, pretty printing, slicing, etc.)
> which does a fantastic job and is up to the task speed wise.
>
> NOTE: Translating code from an imperative language lets say Fortran to
> Bigloo is easy. A lot of Fortran code consists of do loops which
> Bigloo you might uses as well:
>
> ==
> (do ((i 0 (+fx i 1))
>      ((=fx i dim))
>      (do ... etc.
> ==
>
> The only issue: Bigloo like C is 0 based and in my case I always think
> in row order instead of Fortran column order scheme.
>
> If you don't use Bigloo and recipies and suggestions posted above
> Bigloo is dog slow. However, it is really very simple and comes more
> or less at no cost to tailor it to a bespoken powerhorse.
>
> Whenever anyone writes a binding for a well respected external C
> library which a lot of people might be  interested in please make it
> public (yes, yes, I for mself haven't done it yet for dislin and
> clapack, etc.). In the hope scientists will stop using Micky Mouse
> languages like Matlab or Python with is a pain in the ass.
>
> Bigloo also makes available classes for java. However, I have no idea
> if this works well or not and if there are people out there who are
> using Bigloo in Java for numerical work.
>
> That said: a big question mark: I haven't seen any detailed
> descriptions of Bigloo and how to employ threads to use dual-core or
> multi processors even in numerical code.
>
> If anone likes to come forward please do so and report of your
> experience using Bigloo in a multi processor farm.
>
> Thanks, Rumpelstilzchen