source: project/release/3/mat5-lib/trunk/mat5-lib-eggdoc.scm @ 11550

Last change on this file since 11550 was 11550, checked in by Ivan Raikov, 12 years ago

Updates to license text; eliminated use of syntax-case.

File size: 23.9 KB
Line 
1;;
2;;
3;; mat5-lib documentation for the Chicken Scheme module system.
4;;
5;;
6;; This program is free software: you can redistribute it and/or
7;; modify it under the terms of the GNU General Public License as
8;; published by the Free Software Foundation, either version 3 of the
9;; License, or (at your option) any later version.
10;;
11;; This program is distributed in the hope that it will be useful, but
12;; WITHOUT ANY WARRANTY; without even the implied warranty of
13;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14;; General Public License for more details.
15;;
16;; A full copy of the GPL license can be found at
17;; <http://www.gnu.org/licenses/>.
18;;
19;;
20
21(use eggdoc)
22
23(define mat5-lib-eggdoc:css (make-parameter #<<EOF
24 <!--
25      CODE {
26            color: #666666;
27          }
28/*   DT.definition EM { font-weight: bold; font-style: normal; } */
29
30     DT.definition { 
31                   background: #eee;
32                   color: black;
33                   padding: 0.2em 1em 0.2em 0.7em;
34                   margin-left: 0.2em;
35border: 1px solid #bbc;
36                   font-family: "Andale Mono", monospace;
37                   /* font-size: 1.2em; */
38                   
39                 }
40     DD {
41                   margin-top: 0.8em;
42                   margin-bottom: 0.8em;
43     }
44     DIV.subsection {
45                    border-top: 1px solid #448;
46                    padding-left: 1em;
47                    margin-bottom: 1.2em;
48     }
49     DIV.subsubsection {
50                    border-top: 1px dotted #99c;
51                    /* border-left: 1px solid #99c; */
52                    padding-left: 1em;
53                    margin-bottom: 1.2em;
54     }
55     DIV.subsubsubsection {
56                    border-top: 1px solid #ddf;
57                    padding-left: 1em;
58                    margin-bottom: 1.2em;
59     }
60
61         DIV.section {
62                 margin-bottom: 1.5em;
63         }
64         a:link {
65                 color: #336;
66         }
67         a:visited { color: #666; }
68         a:active  { color: #966; }
69         a:hover   { color: #669; }
70         body { margin: 0; padding: 0; background: #fff; color: #000; font: 9pt "Lucida Grande", "Verdana", sans-serif; }
71         H2 {
72                 background: #336;
73                 color: #fff;
74                 padding-top: 0.5em;
75                 padding-bottom: 0.5em;
76                 padding-left: 16px;
77                 margin: 0 0 1em 0;
78        }
79        UL LI {
80                list-style: none;
81        }
82        TT {
83                font-family: "Andale Mono", monospace;
84                /* font-size: 1.2em; */
85        }
86        H3 {
87                color: #113;
88                margin-bottom: 0.5em;
89        }
90        H4, H5, H6 {
91                color: #113;
92                margin-bottom: 1.0em;
93        }
94        H5 {
95                font-weight: normal;
96                font-style: italic;
97                font-size: 100%;
98                margin-top: 1.2em;
99        }
100        H6 {
101                font-weight: bold;
102                font-size: 85%;
103                margin-top: 1.2em;
104        }
105     DIV#eggheader {
106         text-align: center;
107                 float: right;
108                 margin-right: 2em;
109     }
110     DIV#header IMG {
111            /* display: block; margin-left: auto; margin-right: auto;  */
112            /* float: right; */
113            border: none;  /* firefox */
114     }
115     DIV#footer {
116                background: #bbd;
117                padding: 0.7em ;
118                border-top: 1px solid #cce;
119     }
120     DIV#footer hr {
121                display: none;
122     }
123     DIV#footer a {
124                float: left;
125     }
126     DIV#revision-history {
127         float: right;
128     }
129     
130     DIV#body {
131                 margin: 1em 1em 1em 16px;
132         }
133
134     DIV#examples PRE {
135       background: #eef;
136       padding: 0.1em;
137       border: 1px solid #aac;
138     }
139     PRE#license, DIV#examples PRE {
140       padding: 0.5em;
141     }
142     DIV#examples PRE {
143       /* font-size: 85%; */
144     }
145     PRE { font-family: "Andale Mono", monospace; }
146     TABLE {
147       background: #eef;
148       padding: 0.2em;
149       border: 1px solid #aac;
150       border-collapse: collapse;
151       width: 100%;
152     }
153     TABLE.symbol-table TD.symbol {
154          width: 15em;
155          font-family: "Andale Mono", monospace;
156          vertical-align: top;
157          /* font-size: 1.2em; */
158     }
159     TABLE.symbol-table TD {
160          font-family: "Andale Mono", monospace;
161          vertical-align: top;
162          /* font-size: 1.2em; */
163     }
164     TH {
165       text-align: left;
166       border-bottom: 1px solid #aac;
167       padding: 0.25em 0.5em 0.25em 0.5em;
168     } 
169     TD { padding: 0.25em 0.5em 0.25em 0.5em; }
170     -->
171EOF
172))
173
174(define doc
175  `((eggdoc:begin
176     (name "mat5-lib")
177     (description "A library of routines for reading and writing in Level 5 MAT-File format.")
178     (author (url "http://chicken.wiki.br/ivan raikov" "Ivan Raikov"))
179
180     (history 
181      (version "1.10" "Eliminated the use of syntax-case; small updates to the license information")
182      (version "1.9" "Some formatting improvements to the documentation")
183      (version "1.8" "Build script updated for better cross-platform compatibility")
184      (version "1.7" "Bug fix in the setup script")
185      (version "1.6" "eggdoc documentation fix")
186      (version "1.5" "License upgrade to GPL v3")
187      (version "1.4" "Bug fixes in the sparse array read and write routines")
188      (version "1.3" "Added support for chicken-setup -test")
189      (version "1.2" "Minor updates to the documentation and the egg configuration files")
190      (version "1.1" "Numerous bug fixes in the structure/object write routines")
191      (version "1.0" "Initial release"))
192
193     (requires (url "datatype.html" "datatype")
194               (url "endian-port.html" "endian-port")
195               (url "iset.html" "iset")
196               (url "srfi-40.html" "srfi-40")
197               (url "srfi-47.html" "srfi-47")
198               (url "z3.html" "z3"))
199
200     (usage "(require-extension mat5-lib)")
201
202     (download "mat5-lib.egg")
203
204     (documentation
205      (p "mat5-lib is a library of routines for reading and writing in "
206         (url "http://www.mathworks.com/access/helpdesk/help/pdf_doc/matlab/matfile_format.pdf" 
207              "Level 5 MAT-File format") ". "
208         "It provides functions to read and write Scheme arrays and
209vectors in the MAT-File format, as well as Scheme representations of
210MAT-File cells, structures, and objects.")
211
212
213       (subsection "MAT-File data types and records"
214
215                   ,(eggdoc:make-defsig 
216                     'datatype "(define-datatype MAT5:data-type MAT5:data-type? ...)"
217                      `(p "Representation of MAT-File data types:"
218                          (symbol-table 
219                           (describe "(miINT8)"   "8-bit, signed")
220                           (describe "(miUINT8)"  "8-bit unsigned")
221                           (describe "(miINT16)"  "16-bit, signed")
222                           (describe "(miUINT16)" "16-bit unsigned")
223                           (describe "(miINT32)"  "32-bit, signed") 
224                           (describe "(miUINT32)" "32-bit, unsigned")
225                           (describe "(miSINGLE)" "IEEE 754 single precision")     
226                           (describe "(miDOUBLE)" "IEEE 754 double precision")     
227                           (describe "(miINT64)"  "64-bit, signed")     
228                           (describe "(miUINT64)" "64-bit, unsigned")     
229                           (describe "(miMATRIX)" "MAT-File array")     
230                           (describe "(miCOMPRESSED)" "Compressed data")
231                           (describe "(miUTF8)"   "Unicode UTF-8 encoded character data")     
232                           (describe "(miUTF16)"  "Unicode UTF-16 encoded character data")
233                           (describe "(miUTF32)"  "Unicode UTF-32 encoded character data"))))
234
235                   (record "(define-record MAT5:header  magic text subsys version eport)"
236                           (p "A record type that represents MAT-file Level 5 headers."
237                              (symbol-table
238                               (describe "text"    "header text (byte vector of size 116)")
239                               (describe "subsys"  "subsystem-specific (byte vector of size 8)")
240                               (describe "version" ("unsigned 16-bit version number" 
241                                                      " (always " (tt "0x0100") ")"))
242                               (describe "eport"   ("an endian port (see module " 
243                                                      (url "endian-port.html" "endian-port") ")")))))
244
245                   (record "(define-record MAT5:data-element type bytes data)"
246                           (p "A record type that represents MAT-file Level 5 data elements."
247                              (symbol-table
248                               (describe "type"  ("is of type " (tt "MAT5:data-type")))
249                               (describe "bytes" "is the size of the data element in bytes")
250                               (describe "data"  ("is the data element object -- either a fixnum/flonum or a " 
251                                                  (tt "MAT5:array") " object")))))
252                   
253                   ,(eggdoc:make-defsig 
254                     'datatype "(define-datatype MAT5:array MAT5:array? ...)"
255                     `(p "A representation of the different types of MAT-file arrays:"
256                         (symbol-table
257
258                          (describe "(MAT5:num-array name data-type dims real imag)"
259                                    (p "A MAT-file numeric array. " 
260                                       "A numeric array is represented as "
261                                       "either an SRFI-47 array, or an SRFI-40 stream in which " 
262                                       "every element is an SRFI-4 column vector:"
263                                       (symbol-table
264                                        (describe "name"        "array name (string)")
265                                        (describe "data-type"   "array element type (must be one of the numeric types)")
266                                        (describe "dims"        "array dimensions (a list of positive integers)")
267                                        (describe "real"        "real part (an SRFI-47 array or a stream of column vectors)")
268                                        (describe "imag"        ("imaginary part "
269                                                                 "(the same representation as the real part, or #f)")))))
270                         
271                         (describe "(MAT5:sparse-array name data-type dims row-index col-index real imag)"
272                                   (p "A MAT-file numeric sparse array. " 
273                                      "A numeric sparse array is represented as "
274                                      "either an SRFI-47 array, or an SRFI-40 stream in which " 
275                                      "every element is an SRFI-4 column vector:"
276                                      (symbol-table 
277                                       (describe "name"        "array name (string)")
278                                       (describe "data-type"   "array element type (must be one of the numeric types)")
279                                       (describe "dims"        "array dimensions (a list of positive integers)")
280                                       (describe "row-index"   "row indices of non-zero elements")
281                                       (describe "col-index"   "column indices of non-zero elements")
282                                       (describe "real"        "real part (an SRFI-47 array or a stream of column vectors)")
283                                       (describe "imag"        ("imaginary part "
284                                                                "(the same representation as the real part, or #f)")))))
285                         
286
287                         (describe "(MAT5:cell-array name dims cell)"
288                                   (p "A MAT-file cell array:"
289                                      (symbol-table
290                                       (describe "name" "array name (string)")
291                                       (describe "dims" "array dimensions (a list of positive integers)")
292                                       (describe "cell" ("a " (tt "MAT5:cell") " object in which every element "
293                                                         "is a " (tt "MAT5:data-element"))))))
294
295                         (describe "(MAT5:structure name dims field-names fields)"
296                                   (p "A MAT-file structure is represented by a "
297                                      (tt "MAT5:cell") " object in which every element is an " 
298                                      "association list that contains the fields of the structure:"
299                                      (symbol-table
300                                       (describe "name" "array name (string)")
301                                       (describe "dims" "array dimensions (a list of positive integers)")
302                                       (describe "class-name" "class name (string)")
303                                       (describe "field-names" "the names of the class fields (a list of strings)")
304                                       (describe "fields" ("a " (tt "MAT5:cell") " object in which every element "
305                                                           "is an association list of fields")))))
306
307                         (describe "(MAT5:object name dims class-name field-names fields)" 
308                                   (p "A MAT5 object data element has the same subelements as a structure, "
309                                      "plus a class name subelement: "
310                                      (symbol-table 
311                                       (describe "name"        "array name (string)")
312                                       (describe "dims"        "array dimensions (a list of positive integers)")
313                                       (describe "class-name"  "class name (string)")
314                                       (describe "field-names" "the names of the class fields (a list of strings)")
315                                       (describe "fields" ("a " (tt "MAT5:cell") " object in which every element "
316                                                           "is an association list of fields"))))))))
317                   
318                   (record "(define-record MAT5:cell dims data)"
319                           (p "A representation of MAT-File cells."
320                              (symbol-table
321                               (describe "dims"    "cell dimensions")
322                               (describe "data"    ("an R5RS non-homogenous array that contains " 
323                                                    "elements of type " (tt "MAT5:array") "."))))))
324
325
326       (subsection "MAT-File routines"
327                   (subsubsection "Predicates and routines for handling MAT-file datatypes and structures"
328                                 
329                                  (procedure "MAT5:numeric-type?:: MAT5:DATA-TYPE -> BOOLEAN"
330                                             (p "Returns true if the given type is an atomic numeric type."))
331                                 
332                                  (procedure "MAT5:array-type?:: MAT5:DATA-TYPE -> BOOLEAN"
333                                             (p "Returns true if the given type is an array type.")))
334                                 
335
336                   (subsubsection "MAT5 cell routines"
337
338                                  (procedure "init-MAT5:cell:: UINTEGER * ... -> MAT5:CELL"
339                                             (p "Create a new MAT5:cell object with the specified dimensions. "
340                                                "The dimensions must all be positive integers, "
341                                                "and at least one dimension must be specified."))
342                                 
343                                  (procedure "MAT5:cell-ref:: MAT5:CELL * UINTEGER ... -> VALUE"
344                                        (p "Given a " (tt "MAT5:cell")  " object and an index, "
345                                           "returns the value found at that index in the cell. "
346                                           "The index must be a list of positive integers, "
347                                           "and it must be within the bounds of the cell dimensions."))
348
349                                  (procedure "MAT5:cell-set!:: MAT5:CELL * VALUE * UINTEGER ... -> UNDEFINED"
350                                             (p "Given a " (tt "MAT5:cell") " object and an index, "
351                                                "destructively replaces the element at the given index "
352                                                "of the cell with the given value."))
353
354                                  (procedure "vector->MAT5:cell:: VECTOR * UINTEGER LIST [* ORDER] -> MAT5:CELL"
355                                             ((p "Given a vector, creates a new " (tt "MAT5:cell") " object that "
356                                                 "consists of the elements of the vector. "
357                                                 "The vector must be of length equal to the "
358                                                 "total size of the array, and its elements are used to initialize the "
359                                                 "cell in either row-major order (left to right and top to bottom), or "
360                                                 "in column-major order (top to bottom and then left to right). ")
361                                              (p "The optional argument " (tt "ORDER") 
362                                                 " specifies the initialization order and "
363                                                 "can be either " (tt "'row-major") " or " (tt "'col-major") ". "
364                                                 "The default is " (tt "'row-major") "."))))
365
366                   (subsubsection "MAT5 array routines"
367                                  (procedure "MAT5:array-foldi:: (INDEX * VALUE * AX -> AX) [* ORDER] -> MAT5:ARRAY * AX -> AX"
368                                             ((p "Iterator function for non-homogenous " (tt "MAT5:array") " objects; "
369                                                 "that is, objects that are either " (tt "MAT5:cell-array") 
370                                                 " (MAT-File cell) or " (tt "MAT5:structure") " (MAT-File structure). ")
371                                              (p "Analogous to the list iterator, this procedure repeatedly applies "
372                                                 "the given function to each element of the array, and accumulates the "
373                                                 "return value. The order of iteration is specified by the optional "
374                                                 "argument " (tt "ORDER")", which can be " (tt "'row-major") 
375                                                 " (left to right and top to bottom) or " (tt "'col-major") 
376                                                 "(top to bottom and then left to right). " 
377                                                 "The default  is " (tt "'row-major") "."))))
378
379                   (subsubsection "MAT-File routines for reading"
380
381                                 (procedure "MAT5:read-header:: ENDIAN-PORT -> MAT5:HEADER"
382                                            (p "Reads a MAT-File header from the given endian port. "
383                                               "Returns a " (tt "MAT5:header") " record."))
384                                 
385                                 (procedure "MAT5:read-data-element:: ENDIAN-PORT -> MAT5:DATA-ELEMENT"
386                                            (p "Reads the next MAT-File data element from the given endian port. "
387                                               "Returns a " (tt "MAT5:data-element") " record."))
388                                 
389                                 (procedure "MAT5:read-stream:: ENDIAN-PORT -> STREAM"
390                                            (p "Creates an SRFI-40 stream that has the MAT-File header from "
391                                               "the given endian port as its first element, "
392                                               "followed by all MAT-File data elements that can be read from the "
393                                               "endian port. "
394                                               "Any elements that are numeric arrays, or contain numeric arrays "
395                                               "will be read lazily; i.e. the corresponding " (tt "DATA") 
396                                               " field will be another SRFI-40 stream containing the "
397                                               "column vectors of the numeric array."))
398
399                                 (procedure "MAT5:stream-read-data-element:: ENDIAN-PORT -> STREAM"
400                                            (p "Reads the next data element from the MAT-File. "
401                                               "If the element is a numeric array, "
402                                               "or if it contains numeric arrays, its numeric data "
403                                               "will be read lazily; i.e. the corresponding " (tt "DATA") 
404                                               " field will be an SRFI-40 stream containing the "
405                                               "column vectors of the numeric array.")))
406
407
408                   (subsubsection "MAT-File routines for writing"
409
410                                 (procedure "MAT5:write-header:: ENDIAN-PORT * TEXT * SUBSYS -> UNDEFINED"
411                                            (p "Writes a MAT-File header to the given endian port. "
412                                               "Arguments " (tt "TEXT") " and " (tt "SUBSYS")  " are strings. " 
413                                               "If they are longer than their maximum permitted lengths "
414                                               "(116 and 8, respectively), they will be truncated."))
415
416                                 (procedure "MAT5:write-data-element:: ENDIAN-PORT * VALUE -> BYTES"
417                                            (p "Writes a data element to the given endian port. "
418                                               (tt "VALUE") " can be one of the following types: "
419                                               (ul (li (tt "MAT5:array?"))
420                                                   (li (tt "string?"))
421                                                   (li (tt "s8vector?"))
422                                                   (li (tt "u8vector?"))
423                                                   (li (tt "s16vector?"))
424                                                   (li (tt "u16vector?"))
425                                                   (li (tt "s32vector?"))
426                                                   (li (tt "u32vector?"))
427                                                   (li (tt "f32vector?"))
428                                                   (li (tt "f64vector?")))))
429
430                                 (procedure "MAT5:write-stream:: ENDIAN-PORT * TEXT * SUBSYS * STREAM -> UNDEFINED"
431                                            (p "Given an endian port, and an SRFI-40 stream consisting of "
432                                               (tt "MAT5:data-element") " objects, this routines writes "
433                                               "a MAT-File header and all elements in the stream to the endian port. "
434                                               "If any numeric arrays are contained in the input stream, "
435                                               "it is expected that their data elements are encoded as SRFI-40 "
436                                               "streams containing the column vectors of the array."))
437
438                                 (procedure "MAT5:stream-write-data-element:: ENDIAN-PORT * VALUE -> BYTES"
439                                            (p "Writes a MAT-File data element to the given endian port. "
440                                               "If the input element is an array, any numeric array data "
441                                               "must be encoded as an SRFI-40 stream, "
442                                               "where each element of the stream is a column vector of the array.")))))
443
444     (examples (pre #<<EOF
445;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
446;;
447;; Example from the MAT-File documentation
448;;
449;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
450(let* ((eport+path (let-values (((fd temp-path) (file-mkstemp "/tmp/mat5-test.XXXXXX")))
451                               (let ((temp-port (open-output-file* fd)))
452                                 (cons (port->endian-port temp-port) temp-path))))
453       (eport (car eport+path))
454       (temp-path (cdr eport+path)))
455
456  (let ((aa (let ((real (make-array (ar32 0) 2 2))
457                  (imag (make-array (ar32 0) 2 2)))
458             
459              (array-set! real 1.0  0 0)
460              (array-set! real 3.0  0 1)
461              (array-set! real 2.0  1 0)
462              (array-set! real 4.0  1 1)
463             
464              (array-set! imag 1.1  0 0)
465             
466              (MAT5:num-array  "my_array" (miSINGLE) '(2 2) real imag))))
467       
468    ;; Write MAT5 file header
469    (MAT5:write-header eport "MATLAB 5.0 MAT-file" "")
470
471    ;; Write test array aa
472    (MAT5:write-data-element eport aa)
473
474    ;; Close endian port for writing
475    (close-endian-port eport)
476   
477    ;; Reopen endian port for reading
478    (let ((eport (open-endian-port 'read temp-path)))
479
480      ;; Read header from file
481      (print (MAT5:read-header eport))
482
483      ;; Read array from file
484      (print (MAT5:read-data-element eport))
485
486      ;; Close endian port for reading
487      (close-endian-port eport))))
488
489
490;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
491;;
492;; Reading and writing via the stream interface
493;;
494;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
495(let* ((eport+path (let-values (((fd temp-path) (file-mkstemp "/tmp/mat5-test.XXXXXX")))
496                               (let ((temp-port (open-output-file* fd)))
497                                 (cons (port->endian-port temp-port) temp-path))))
498       (eport (car eport+path))
499       (temp-path (cdr eport+path)))
500
501  (let ((aa (let ((av (stream (stream (list->f64vector '(2.0 5.0))
502                                      (list->f64vector '(1.0 3.0))
503                                      (list->f64vector '(4.0 6.0)))
504                             
505                              (stream (list->f64vector '(7.0  10.0))
506                                      (list->f64vector '(13.0 16.0))
507                                      (list->f64vector '(19.0 22.0)))
508                             
509                              (stream (list->f64vector '(8.0  11.0))
510                                      (list->f64vector '(14.0 17.0))
511                                      (list->f64vector '(20.0 23.0)))
512                             
513                              (stream (list->f64vector '(9.0  12.0)))
514                              (list->f64vector '(15.0 18.0))
515                              (list->f64vector '(21.0 24.0)))))
516                  (MAT5:num-array  "aa2" (miDOUBLE) '(2 3 ??) av  #f))))
517
518    ;; Write MAT5 file header
519    (MAT5:write-header eport "MATLAB 5.0 MAT-file" "")
520   
521    ;; Write test array aa
522    (MAT5:stream-write-data-element eport aa)
523
524    ;; Close endian port for writing
525    (close-endian-port eport)
526
527    ;; Reopen endian port for reading
528    (let* ((eport (open-endian-port 'read temp-path))
529           ;; Create read stream
530           (stream (MAT5:read-stream eport))
531           ;; First stream element
532           (header (stream-car stream))
533           ;; Second stream element
534           (el2 (stream-car (stream-cdr stream))))
535     
536      ;; "Contents of second stream element"
537      (for-each
538       (lambda (x) 
539         (if (MAT5:array-type? (MAT5:data-element-type x))
540             (cases MAT5:array (MAT5:data-element-data x)
541                    (MAT5:num-array (name data-type dims real imag)
542                                    (stream-for-each (lambda (x) (print "column: " x)) real))
543                    (else (print data)))
544             (else (print x))))
545       el2))
546   
547   ;; Close endian port for reading
548    (close-endian-port eport)))
549
550;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
551;;
552;; Structure example from the MAT-File documentation
553;;
554;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
555(let* ((eport+path (let-values (((fd temp-path) (file-mkstemp "/tmp/mat5-test.XXXXXX")))
556                               (let ((temp-port (open-output-file* fd)))
557                                 (cons (port->endian-port temp-port) temp-path))))
558       (eport (car eport+path))
559       (temp-path (cdr eport+path)))
560
561
562  (let ((aa (let ((av (init-MAT5:cell 1 1))
563                  (w  (make-array (ar64 0) 1 1))
564                  (y  (make-array (ar64 0) 1 1))
565                  (z  (make-array (ar64 0) 1 1)))
566             
567              (array-set! w 1.0  0 0)
568              (array-set! y 2.0  0 0)
569              (array-set! z 3.0  0 0)
570             
571              (MAT5:cell-set! av 
572                              `(,(MAT5:num-array "w" (miDOUBLE) '(1 1) w #f) 
573                                ,(MAT5:num-array "y" (miDOUBLE) '(1 1) y #f)
574                                ,(MAT5:num-array "z" (miDOUBLE) '(1 1) z #f))
575                              0 0)
576             
577              (MAT5:structure  "aa1" '(1 1) '("w" "y" "z")  av))))
578
579    ;; Write MAT5 file header
580    (MAT5:write-header eport "MATLAB 5.0 MAT-file" "")
581
582    ;; Write test structure aa
583    (MAT5:write-data-element eport aa)
584
585    ;; Close endian port for writing
586    (close-endian-port eport)
587   
588    ;; Reopen endian port for reading
589    (let ((eport (open-endian-port 'read temp-path)))
590
591      ;; Read header from file
592      (print (MAT5:read-header eport))
593
594      ;; Read array from file
595      (print (MAT5:read-data-element eport))
596
597      ;; Close endian port for reading
598      (close-endian-port eport))))
599   
600
601EOF
602))
603
604     (license
605      "Copyright 2005-2008 Ivan Raikov and the Georgia Institute of Technology
606
607This program is free software: you can redistribute it and/or modify
608it under the terms of the GNU General Public License as published by
609the Free Software Foundation, either version 3 of the License, or (at
610your option) any later version.
611
612This program is distributed in the hope that it will be useful, but
613WITHOUT ANY WARRANTY; without even the implied warranty of
614MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
615General Public License for more details.
616
617A full copy of the GPL license can be found at
618<http://www.gnu.org/licenses/>."))))
619
620
621(if (eggdoc->html doc 
622                   `( (eggdoc-style . ,(lambda (tag)
623                         `("<style type=\"text/css\">" ,(mat5-lib-eggdoc:css)
624                           "</style>")))
625                      (documentation *macro* . ,(lambda (tag . elts)
626                        (let* ((sections
627                                (pre-post-order elts
628                                                `((subsection   ;; (subsection level "content ...")
629                                                   ((*text* . ,(lambda (tag str) str)))
630                                                   . ,(lambda (tag head-word . elems)
631                                                        `(li (a (@ (href ,(string-append "#" head-word)))
632                                                                ,head-word))))
633                                                  (*default*
634                                                   . ,(lambda (tag . elems) (list)))
635                                                 
636                                                  (*text* . ,(lambda (trigger str) (list))))))
637                               (toc `(div (@ (class "toc"))
638                                          (ol ,sections))))
639                          `(section "Documentation" ,(cons toc elts)))))
640                      ,@(eggdoc:make-stylesheet doc) ))
641
642    (void))
Note: See TracBrowser for help on using the repository browser.