Coverage report: /home/ellis/comp/core/lib/obj/tensor/print.lisp

KindCoveredAll%
expression0264 0.0
branch022 0.0
Key
Not instrumented
Conditionalized out
Executed
Not executed
 
Both branches taken
One branch taken
Neither branch taken
1
 ;;; print.lisp --- Tensor Printer
2
 
3
 ;; 
4
 
5
 ;;; Code:
6
 (in-package :obj/tensor)
7
 ;;; PRINT
8
 (defun print-tensor (tensor stream)
9
   (let ((rank (rank tensor))
10
         (dims (dimensions tensor))
11
         (two-print-calls 0))
12
     (labels ((two-print (tensor subs)
13
                (let ((strs) (cprints)
14
                      (maxw (make-array (if (eq *print-tensor-max-len* t) (aref dims 1) (1+ *print-tensor-max-len*)) :initial-element 0)))
15
                  (setq strs
16
                        (loop for i from 0 below (aref dims 0)
17
                              if (or (eq *print-tensor-max-len* t) (< i *print-tensor-max-len*))
18
                              collect (loop for j from 0 below (aref dims 1)
19
                                            if (or (eq *print-tensor-max-len* t) (< j *print-tensor-max-len*))
20
                                            do 
21
                                               (let ((str (with-output-to-string (str)
22
                                                            (print-element tensor (ref tensor (append `(,i ,j) subs)) str))))
23
                                                 (push str cprints)
24
                                                 (setf (aref maxw j) (max (aref maxw j) (length str))))
25
                                            else do
26
                                               (let ((str (with-output-to-string (str) (format str "..."))))
27
                                                 (push str cprints)
28
                                                 (setf (aref maxw j) (max (aref maxw j) (length str)))
29
                                                 (return cprints))
30
                                            finally (return cprints))
31
                              into rprints
32
                              finally (return rprints)))
33
                  (loop for row in strs
34
                        do (format stream (format nil "~~~AT" *print-tensor-indent*))
35
                        do 
36
                           (loop for cref in row
37
                                 with j = 0
38
                                 do (format stream (replace (make-string (+ (aref maxw j) 4) :initial-element #\Space) cref :start1 (if (char= (aref cref 0) #\-) 0 1)))
39
                                 do (incf j))
40
                        do (format stream "~%"))
41
                  (unless (or (eq *print-tensor-max-len* t) (< (aref dims 0) *print-tensor-max-len*))
42
                    (format stream (format nil "~~~AT.~~%~~~:*~AT:~~%" *print-tensor-indent*)))))
43
              (rec-print (tensor idx subs)
44
                (if (>= idx 2)
45
                    (dotimes (i (aref dims idx) t)
46
                      (unless (rec-print tensor (1- idx) (append `(,i) subs))
47
                        (return nil)))
48
                    (progn
49
                      (if (or (eq *print-tensor-max-args* t) (< two-print-calls *print-tensor-max-args*))
50
                          (progn
51
                            (format stream "~A~%" (append '(\: \:) subs))
52
                            (two-print tensor subs)
53
                            (format stream "~%")
54
                            (incf two-print-calls)
55
                            t)
56
                          (progn
57
                            (format stream "~A~%" (make-list rank :initial-element '\:))
58
                            (format stream (format nil "~~~AT..~~%~~~AT::~~%" *print-tensor-indent* *print-tensor-indent*))
59
                            nil))))))
60
       (case rank
61
         (1
62
          (format stream (format nil "~~~AT" *print-tensor-indent*))
63
          (dotimes (i (aref dims 0))
64
            (if (or (eq *print-tensor-max-len* t) (< i *print-tensor-max-len*))
65
                (progn
66
                  (print-element tensor (ref tensor i) stream)
67
                  (format stream "~,4T"))
68
                (progn
69
                  (format stream "...")
70
                  (return nil))))
71
          (format stream "~%"))
72
         (2
73
          (two-print tensor nil))
74
         (t
75
          (rec-print tensor (1- (rank tensor)) nil))))))
76
 
77
 (defmethod print-object ((tensor standard-tensor) stream)
78
   (declare (optimize (safety 0) (debug 1)))
79
   (print-unreadable-object (tensor stream :type t)
80
     (let ((dims (dimensions tensor)))
81
       ;; (if ;; (and (slot-value tensor 'parent-tensor) dims)
82
       ;; dims
83
       ;; (format stream "~A~,4T:DISPLACED" dims)
84
        (format stream "~A" dims)
85
       ;; )
86
       (when (> (size tensor) 0)
87
         (format stream "~%")
88
         (print-tensor tensor stream)))))
89
 
90
 (defmethod print-object ((tensor sparse-tensor) stream)
91
   (declare (optimize (safety 0) (debug 1)))
92
   (print-unreadable-object (tensor stream :type t)
93
     (format stream
94
             (concatenate 'string
95
                          "~A, store-size: ~A"
96
                          (if (slot-value tensor 'parent-tensor) ",4T:DISPLACED" ""))
97
             (dimensions tensor) (store-size tensor))))