Home     About     Download     Resources     Contact us

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

Browse thread
[Caml-list] Objects or modules ?
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2002-07-04 (23:54) From: Nicolas FRANCOIS Subject: Re: [Caml-list] Objects or modules ?
```Le Thu, 4 Jul 2002 01:16:11 +0200 Nicolas FRANCOIS (AKA El Bofo)
<nicolas.francois@free.fr> a écrit :

> Le Sat, 29 Jun 2002 12:22:52 +0200 Markus Mottl <markus@oefai.at> a
> écrit:
>
> > You might also want to take a look at Christophe Raffalli's library
> > for formal and numerical calculus to grab a few ideas:
> >
> >   http://lama-d134.univ-savoie.fr/sitelama/Membres/pages_web/RAFFALLI/formel.html
>
> OK, I got it. If I really understand this, this is a pre-project for
> FOC. Am I right ?
>
> Now that I adapted it to OCaml 3.04 (Streams not recognized by standard
> OCaml now), I have a new problem : this is a definition for a quotient
> ring (there's a similar one for a quotient field in case the ideal is
> primitive) ;
>
> (in algebra.mli)
> module Quotient :
>   functor(R : Euclidian_Ring) ->
>     functor(Elt : One_element with type elem = R.elem) ->
>       Ring with type elem = R.elem
>
> (in algebra.ml)
> module Quotient =
>   functor (R : Euclidian_Ring) ->
>   functor (Elt : One_element with type elem = R.elem) ->
>   struct
>     type elem = R.elem
>     let zero = R.zero
>     let one = R.one
>     let t_of_int = R.t_of_int
>     let (++) = R.(++)
>     let (--) = R.(--)
>     let ( ** ) = R.( ** )
>     let (==) a b = R.(==) (R.(mod) (R.(--) a b) Elt.elt) R.zero
>     let opp = R.opp
>     let normalize x = R.(mod) (R.normalize x) Elt.elt
>     let print x = R.print (normalize x)
>     let write ch x = R.write ch (normalize x)
>     let parse = R.parse
>     let read = R.read
>     let write_bin ch x = R.write_bin ch (normalize x)
>     let read_bin = R.read_bin
>     let conjugate = R.conjugate
>   end
>
> I'd like to use this functor to create a ring Z/pZ, providing a
> (possibliy prime) integer p. My problem is : what is the correct way to
> use this ?

OK, I found a way :

(file essai.ml)
open Algebra

module Five : (One_element with type elem = Ring_MZ.elem) =
struct
type elem = Ring_MZ.elem
let elt = Ring_MZ.t_of_int 5
end
open Five

module Z5Z = Quotient_prime (Ring_MZ) (Five)

open Polynomial

module P = Make(Z5Z)

open P

let p1 = monome (Z5Z.t_of_int 8) 0
++ monome (Z5Z.t_of_int 4) 1
++ monome (Z5Z.t_of_int 1) 2;;

let p2 = monome (Z5Z.t_of_int 3) 1
++ monome (Z5Z.t_of_int 1) 12
++ monome (Z5Z.t_of_int 2) 14;;

print (p1 ** (p2 // p1) ++ (p2 mod p1) -- p2)

(The end for the ones how know the package Formel)

Is there a way to do things simpler ?

\bye

--

Nicolas FRANCOIS
http://nicolas.francois.free.fr
A TRUE Klingon programmer does NOT comment his code
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

```