source: project/mat5-lib/trunk/mat5-lib-eggdoc.scm @ 7358

Last change on this file since 7358 was 7358, checked in by Ivan Raikov, 13 years ago

Updated author address.

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