;; simde example (WIP)

(define %vec-a (vector-unfold (lambda (i)
                                (* i i))
                              5))

;; take vec-a's length at compile-time
(define %len-a (vector-length %vec-a))


(define foox
  (external "computefoox" (=> (integer integer) integer)
            (lambda (x y)
              (display (+ x y)))))

(define (handle-error message)
  (define out (current-error-port))
  (error message))

;;(define-c-generator make-string #t
;;  (lambda (call port indent)
;;    ; calloc is used as a hack to get a zero at the end
;;    (format port "(char *)calloc( 1, 1 + ")
;;    (c-value (call-arg call 0) port)
;;    (format port ")")))

;; gcvt (float value, int ndigits, char * buf);
(define (gcvt v ndigits buf)
  ((external "gcvt" (=> (float integer (^ char)) unit ) )
   v ndigits buf))

(define-wrapper-type m256d)

;; (define (fmaddf a b c)
;;   ((external "simde_mm256_fmadd_pd" (=> ((^ float) (^ float) (^ float)) (^ float) ) )
;;   a b c))

;; simde__m256d evens4 = simde_mm256_loadu_pd(l1);
(define (simde-loadu ds)
  ((external "simde_mm256_loadu_pd" (=> ((^ float)) m256d))
  ds ))

(define (simde-storeu ds avx)
  ((external "simde_mm256_storeu_pd" (=> ((^ float) m256d) (^ float)))
   ds avx)
  ds )

(define (simde-sub-pd ds1 ds2)
  ((external "simde_mm256_sub_pd" (=> (m256d m256d) m256d))
   ds1 ds2))

(define (main)
  (define out (current-output-port))

  (write-string "SIMDE: Print vec-a with vector-for-each:\n" out)

  (vector-for-each (lambda (i val)
                     (write-string " vec-a[" out)
                     (write-integer i out)
                     (write-string "] = " out)
                     (write-integer val out)
                     (write-string ", " out)
                     )
                   %vec-a %len-a)
  (newline out)
  (let ((target (make-string 20))
        (f 1.2)
        (a (make-vector 10 1.1))
        (b (make-vector 10 1.1))
        (c (make-vector 10 1.1))
        )
    (gcvt f 4 target)
    (write-string target out)
    (newline out)
    (vector-set! a 0 2.2)
    (vector-set! a 1 2.2)
    (vector-set! a 2 4.2)
    (vector-set! a 3 5.2)
    (vector-set! b 0 1.1)
    (vector-set! b 1 2.1)
    (vector-set! b 2 3.1)
    (vector-set! b 3 4.1)
    (let* ((evens (simde-loadu a))
           (odds (simde-loadu b))
           (result (simde-storeu a (simde-sub-pd evens odds))))
      (vector-for-each (lambda (i val)
                         ;; (flonum-set! val i)
                         (gcvt val 4 target)
                         (write-string target out)
                         (newline out)
                         )
                       result 4)
      )
    )
  (newline out)
  0
)