external/clem/test/test-clem2.cl

   1
   2
   3 (in-package :clem-test)
   4
   5 (defparameter *test-matrix-size* 256)
   6
   7 ;;; basic make-instance tests
   8
   9 (defun test/make-instance/integer/1 (&key (size *test-matrix-size*))
  10   (let ((m (make-instance 'clem:integer-matrix :cols size :rows size :initial-element #xFF)))
  11     m))
  12
  13 (defun test/make-instance/bit/1 (&key (size *test-matrix-size*))
  14   (let ((m (make-instance 'clem:bit-matrix :cols size :rows size)))
  15     m))
  16
  17 (defun test/make-instance/bit/2 (&key (size *test-matrix-size*))
  18   (let ((m (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
  19     m))
  20
  21 (defun test/make-instance/ub8/1 (&key (size *test-matrix-size*))
  22   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size)))
  23     m))
  24
  25 (defun test/make-instance/ub8/2 (&key (size *test-matrix-size*))
  26   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 255)))
  27     m))
  28
  29 (defun test/make-instance/sb8 (&key (size *test-matrix-size*))
  30   (let ((m (make-instance 'clem:sb8-matrix :cols size :rows size)))
  31     m))
  32
  33 (defun test/make-instance/ub16 (&key (size *test-matrix-size*))
  34   (let ((m (make-instance 'clem:ub16-matrix :cols size :rows size)))
  35     m))
  36
  37 (defun test/make-instance/sb16 (&key (size *test-matrix-size*))
  38   (let ((m (make-instance 'clem:sb16-matrix :cols size :rows size)))
  39     m))
  40
  41 (defun test/make-instance/single-float (&key (size *test-matrix-size*))
  42   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size)))
  43     m))
  44
  45 (defun test/make-instance/double-float (&key (size *test-matrix-size*))
  46   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size)))
  47     m))
  48
  49 ;;; simple arithmetic tests
  50
  51 (defun test/mat-add/ub8/ub8 (&key (size *test-matrix-size*))
  52   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  53         (n (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 127)))
  54     (let ((p (clem:mat-add m n)))
  55       p)))
  56
  57 (defun test/mat-add/in-place/eub8/ub8 (&key (size *test-matrix-size*))
  58   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  59         (n (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 127)))
  60     (let ((p (clem:mat-add m n :in-place t)))
  61       p)))
  62
  63 (defun test/mat-add/ub8/ub16 (&key (size *test-matrix-size*))
  64   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  65         (n (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 127)))
  66     (let ((p (clem:mat-add m n)))
  67       p)))
  68
  69 (defun test/mat-add/in-place/ub8/ub16 (&key (size *test-matrix-size*))
  70   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  71         (n (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 127)))
  72     (let ((p (clem:mat-add m n :in-place t)))
  73       p)))
  74
  75 (defun test/mat-add/ub8/ub32 (&key (size *test-matrix-size*))
  76   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  77         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 127)))
  78     (let ((p (clem:mat-add m n)))
  79       p)))
  80
  81 (defun test/mat-add/in-place/ub8/ub32 (&key (size *test-matrix-size*))
  82   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  83         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 127)))
  84     (let ((p (clem:mat-add m n :in-place t)))
  85       p)))
  86
  87 ;;;
  88 ;;; What should we do about overflow?
  89 ;;; There are three obvious possibilities:
  90 ;;; 1. fit the value to the type (which is what we do now)
  91 ;;; 2. throw an error
  92 ;;; 3. promote to a type to which the value will fit
  93 ;;;
  94 ;;; I have no idea how best to deal with these three possibilities.
  95 ;;;
  96 (defun test/mat-add/ub8/overflow (&key (size *test-matrix-size*))
  97   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
  98         (n (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128)))
  99     (let ((p (clem:mat-add m n)))
 100       p)))
 101
 102 (defun test/mat-add/sb8 (&key (size *test-matrix-size*))
 103   (let ((m (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 64))
 104         (n (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 63)))
 105     (let ((p (clem:mat-add m n)))
 106       p)))
 107
 108 (defun test/mat-add/ub8/sb8 (&key (size *test-matrix-size*))
 109   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
 110         (n (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 127)))
 111     (let ((p (clem:mat-add m n)))
 112       p)))
 113
 114 (defun test/mat-add/ub8/bit (&key (size *test-matrix-size*))
 115   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
 116         (n (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 117     (let ((p (clem:mat-add m n)))
 118       p)))
 119
 120 (defun test/mat-add/ub8/bit-2 (&key (size *test-matrix-size*))
 121   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 128))
 122         (n (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 123     (time (let ((p (clem:mat-add m n)))
 124             (dotimes (i 32) (clem:mat-add p n :in-place t))))))
 125
 126
 127 ;;; double-float tests
 128
 129 (defun test/mat-add/double-float/double-float (&key (size *test-matrix-size*))
 130   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 131         (n (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0)))
 132     (let ((p (time (clem:mat-add m n))))
 133       p)))
 134
 135 (defun test/mat-add/in-place/double-float/double-float (&key (size *test-matrix-size*))
 136   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 137         (n (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0)))
 138     (let ((p (clem:mat-add m n :in-place t)))
 139       p)))
 140
 141 (defun test/mat-add/double-float/single-float (&key (size *test-matrix-size*))
 142   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 143         (n (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0)))
 144     (let ((p (time (clem:mat-add m n))))
 145       p)))
 146
 147 (defun test/mat-add/double-float/ub8 (&key (size *test-matrix-size*))
 148   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 149         (n (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 1)))
 150     (let ((p (time (clem:mat-add m n))))
 151       p)))
 152
 153 (defun test/mat-add/double-float/ub16 (&key (size *test-matrix-size*))
 154   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 155         (n (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 1)))
 156     (let ((p (time (clem:mat-add m n))))
 157       p)))
 158
 159 (defun test/mat-add/double-float/ub32 (&key (size *test-matrix-size*))
 160   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 161         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 1)))
 162     (let ((p (time (clem:mat-add m n))))
 163       p)))
 164
 165 (defun test/mat-add/in-place/double-float/ub32 (&key (size *test-matrix-size*))
 166   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 167         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element #xffffffff)))
 168     (let ((p (time (clem:mat-add m n :in-place t))))
 169       p)))
 170
 171 (defun test/mat-add/double-float/sb8 (&key (size *test-matrix-size*))
 172   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 173         (n (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 1)))
 174     (let ((p (time (clem:mat-add m n))))
 175       p)))
 176
 177 (defun test/mat-add/double-float/sb16 (&key (size *test-matrix-size*))
 178   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 179         (n (make-instance 'clem:sb16-matrix :cols size :rows size :initial-element 1)))
 180     (let ((p (time (clem:mat-add m n))))
 181       p)))
 182
 183 (defun test/mat-add/double-float/sb32 (&key (size *test-matrix-size*))
 184   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 185         (n (make-instance 'clem:sb32-matrix :cols size :rows size :initial-element 1)))
 186     (let ((p (time (clem:mat-add m n))))
 187       p)))
 188
 189 (defun test/mat-add/double-float/bit (&key (size *test-matrix-size*))
 190   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 191         (n (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 192     (let ((p (time (clem:mat-add m n))))
 193       p)))
 194
 195 (defun test/mat-add/double-float/fixnum (&key (size *test-matrix-size*))
 196   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 197         (n (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 1)))
 198     (let ((p (time (clem:mat-add m n))))
 199       p)))
 200
 201 (defun test/mat-add/in-place/double-float/fixnum (&key (size *test-matrix-size*))
 202   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0))
 203         (n (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 1)))
 204     (let ((p (time (clem:mat-add m n :in-place t))))
 205       p)))
 206
 207
 208 ;;; single-float tests
 209
 210 (defun test/mat-add/single-float/double-float (&key (size *test-matrix-size*))
 211   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 212         (n (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0)))
 213     (let ((p (time (clem:mat-add m n))))
 214       p)))
 215
 216 (defun test/mat-add/single-float/single-float (&key (size *test-matrix-size*))
 217   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 218         (n (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0)))
 219     (let ((p (time (clem:mat-add m n))))
 220       p)))
 221
 222 (defun test/mat-add/single-float/ub8 (&key (size *test-matrix-size*))
 223   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 224         (n (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 1)))
 225     (let ((p (time (clem:mat-add m n))))
 226       p)))
 227
 228 (defun test/mat-add/single-float/ub16 (&key (size *test-matrix-size*))
 229   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 230         (n (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 1)))
 231     (let ((p (time (clem:mat-add m n))))
 232       p)))
 233
 234 (defun test/mat-add/single-float/ub32 (&key (size *test-matrix-size*))
 235   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 236         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 1)))
 237     (let ((p (time (clem:mat-add m n))))
 238       p)))
 239
 240 (defun test/mat-add/in-place/single-float/ub32 (&key (size *test-matrix-size*))
 241   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 242         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element #xffffffff)))
 243     (let ((p (time (clem:mat-add m n :in-place t))))
 244       p)))
 245
 246 (defun test/mat-add/single-float/sb8 (&key (size *test-matrix-size*))
 247   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 248         (n (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 1)))
 249     (let ((p (time (clem:mat-add m n))))
 250       p)))
 251
 252 (defun test/mat-add/single-float/sb16 (&key (size *test-matrix-size*))
 253   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 254         (n (make-instance 'clem:sb16-matrix :cols size :rows size :initial-element 1)))
 255     (let ((p (time (clem:mat-add m n))))
 256       p)))
 257
 258 (defun test/mat-add/single-float/sb32 (&key (size *test-matrix-size*))
 259   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 260         (n (make-instance 'clem:sb32-matrix :cols size :rows size :initial-element 1)))
 261     (let ((p (time (clem:mat-add m n))))
 262       p)))
 263
 264 (defun test/mat-add/single-float/bit (&key (size *test-matrix-size*))
 265   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 266         (n (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 267     (let ((p (time (clem:mat-add m n))))
 268       p)))
 269
 270 (defun test/mat-add/single-float/fixnum (&key (size *test-matrix-size*))
 271   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 272         (n (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 1)))
 273     (let ((p (time (clem:mat-add m n))))
 274       p)))
 275
 276 (defun test/mat-add/in-place/single-float/fixnum (&key (size *test-matrix-size*))
 277   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0))
 278         (n (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 1)))
 279     (let ((p (time (clem:mat-add m n :in-place t))))
 280       p)))
 281
 282
 283
 284 (defun test/mat-add/ub32/ub32 (&key (size *test-matrix-size*))
 285   (let ((m (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 128))
 286         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 127)))
 287     (let ((p (time (clem:mat-add m n))))
 288       p)))
 289
 290 (defun test/mat-add/in-place/ub32/ub32 (&key (size *test-matrix-size*))
 291   (let ((m (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 128))
 292         (n (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 127)))
 293     (let ((p (time (clem:mat-add m n :in-place t))))
 294       p)))
 295
 296 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 297 ;;; mat-scale
 298 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 299
 300 (defun test/mat-scale/double-float (&key (size *test-matrix-size*))
 301   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0)))
 302     (let ((p (time (clem::mat-scale m 2.0d0))))
 303       p)))
 304
 305 (defun test/mat-scale/single-float (&key (size *test-matrix-size*))
 306   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0)))
 307     (let ((p (time (clem::mat-scale m 2.0s0))))
 308       p)))
 309
 310 (defun test/mat-scale/ub8 (&key (size *test-matrix-size*))
 311   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 1)))
 312     (let ((p (time (clem::mat-scale m 2))))
 313       p)))
 314
 315 (defun test/mat-scale/ub16 (&key (size *test-matrix-size*))
 316   (let ((m (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 255)))
 317     (let ((p (time (clem::mat-scale m 255))))
 318       p)))
 319
 320 (defun test/mat-scale/ub32 (&key (size *test-matrix-size*))
 321   (let ((m (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 256)))
 322     (let ((p (time (clem::mat-scale m 256))))
 323       p)))
 324
 325
 326 (defun test/mat-scale/sb8 (&key (size *test-matrix-size*))
 327   (let ((m (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 1)))
 328     (let ((p (time (clem::mat-scale m 2))))
 329       p)))
 330
 331 (defun test/mat-scale/sb16 (&key (size *test-matrix-size*))
 332   (let ((m (make-instance 'clem:sb16-matrix :cols size :rows size :initial-element 127)))
 333     (let ((p (time (clem::mat-scale m 127))))
 334       p)))
 335
 336 (defun test/mat-scale/sb32 (&key (size *test-matrix-size*))
 337   (let ((m (make-instance 'clem:sb32-matrix :cols size :rows size :initial-element 256)))
 338     (let ((p (time (clem::mat-scale m 256))))
 339       p)))
 340
 341 (defun test/mat-scale/bit (&key (size *test-matrix-size*))
 342   (let ((m (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 343     (let ((p (time (clem::mat-scale m 0))))
 344       p)))
 345
 346 (defun test/mat-scale/fixnum (&key (size *test-matrix-size*))
 347   (let ((m (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 256)))
 348     (let ((p (time (clem::mat-scale m 256))))
 349       p)))
 350
 351
 352 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 353 ;;; mat-scale!
 354 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 355
 356 (defun test/mat-scale!/double-float (&key (size *test-matrix-size*))
 357   (let ((m (make-instance 'clem:double-float-matrix :cols size :rows size :initial-element 1.0d0)))
 358     (let ((p (time (clem::mat-scale! m 2.0d0))))
 359       p)))
 360
 361 (defun test/mat-scale!/single-float (&key (size *test-matrix-size*))
 362   (let ((m (make-instance 'clem:single-float-matrix :cols size :rows size :initial-element 1.0s0)))
 363     (let ((p (time (clem::mat-scale! m 2.0s0))))
 364       p)))
 365
 366 (defun test/mat-scale!/ub8 (&key (size *test-matrix-size*))
 367   (let ((m (make-instance 'clem:ub8-matrix :cols size :rows size :initial-element 1)))
 368     (let ((p (time (clem::mat-scale! m 2))))
 369       p)))
 370
 371 (defun test/mat-scale!/ub16 (&key (size *test-matrix-size*))
 372   (let ((m (make-instance 'clem:ub16-matrix :cols size :rows size :initial-element 255)))
 373     (let ((p (time (clem::mat-scale! m 255))))
 374       p)))
 375
 376 (defun test/mat-scale!/ub32 (&key (size *test-matrix-size*))
 377   (let ((m (make-instance 'clem:ub32-matrix :cols size :rows size :initial-element 256)))
 378     (let ((p (time (clem::mat-scale! m 256))))
 379       p)))
 380
 381
 382 (defun test/mat-scale!/sb8 (&key (size *test-matrix-size*))
 383   (let ((m (make-instance 'clem:sb8-matrix :cols size :rows size :initial-element 1)))
 384     (let ((p (time (clem::mat-scale! m 2))))
 385       p)))
 386
 387 (defun test/mat-scale!/sb16 (&key (size *test-matrix-size*))
 388   (let ((m (make-instance 'clem:sb16-matrix :cols size :rows size :initial-element 127)))
 389     (let ((p (time (clem::mat-scale! m -127))))
 390       p)))
 391
 392 (defun test/mat-scale!/sb32 (&key (size *test-matrix-size*))
 393   (let ((m (make-instance 'clem:sb32-matrix :cols size :rows size :initial-element 256)))
 394     (let ((p (time (clem::mat-scale! m 256))))
 395       p)))
 396
 397 (defun test/mat-scale!/bit (&key (size *test-matrix-size*))
 398   (let ((m (make-instance 'clem:bit-matrix :cols size :rows size :initial-element 1)))
 399     (let ((p (time (clem::mat-scale! m 0))))
 400       p)))
 401
 402 (defun test/mat-scale!/fixnum (&key (size *test-matrix-size*))
 403   (let ((m (make-instance 'clem:fixnum-matrix :cols size :rows size :initial-element 256)))
 404     (let ((p (time (clem::mat-scale! m 256))))
 405       p)))