8.039

project.clj

@@ -1,4 +1,4 @@
-(defproject cnuernber/dtype-next "8.039-SNAPSHOT"
+(defproject cnuernber/dtype-next "8.039"
   :description "A Clojure library designed to aid in the implementation of high performance algorithms and systems."
   :url "http://github.com/cnuernber/dtype-next"
   :license {:name "EPL-2.0"

src/tech/v3/datatype/array_buffer.clj

@@ -51,7 +51,7 @@
            ;;For integer types, everything implements readlong.
            ;;They also implement readX where X maps to exactly the datatype.
            ;;For example byte arrays implement readLong and readByte.
-           (casting/integer-type? cast-dtype)
+           (or (= cast-dtype :char) (casting/integer-type? cast-dtype))
            (concat
             [`(readLong [rdr# ~'idx]
                         (casting/datatype->unchecked-cast-fn
@@ -129,7 +129,7 @@
            (= :boolean cast-dtype)
            [`(writeBoolean [wtr# idx# val#]
                            (ArrayHelpers/aset ~'java-ary (pmath/+ ~offset idx#) val#))]
-           (casting/integer-type? cast-dtype)
+           (or (= :char cast-dtype) (casting/integer-type? cast-dtype))
            (concat
             [`(writeLong [rdr# ~'idx ~'value]
                          (ArrayHelpers/aset ~'java-ary (pmath/+ ~offset ~'idx)

src/tech/v3/datatype/base.clj

@@ -689,21 +689,26 @@ tech.v3.tensor.integration-test> (dtype/set-value! (dtype/clone test-tens) [:all
            (fn [op-dtype item]
              (dispatch/typed-map-1 cast-fn new-dtype item))
            (fn [op-dtype item]
-             (case (casting/simple-operation-space new-dtype
-                                                   (elemwise-datatype item))
-               :int64
-               (let [src-rdr (dtype-proto/elemwise-reader-cast item :int64)]
+             (let [ewise-dtype (dtype-proto/operational-elemwise-datatype item)
+                   ^Buffer src-rdr (dtype-proto/elemwise-reader-cast
+                                    item
+                                    ewise-dtype)
+                   number? (casting/numeric-type? ewise-dtype)
+                   simp-op-space (casting/simple-operation-space new-dtype)]
+               (cond
+                 (and number? (identical? simp-op-space :int64))
                  (reify LongReader
                    (elemwiseDatatype [rdr] new-dtype)
                    (lsize [rdr] (.lsize src-rdr))
-                   (readLong [rdr idx] (.readLong src-rdr idx))))
-               :float64
-               (let [src-rdr (dtype-proto/elemwise-reader-cast item :float64)]
+                   ;;We have to call cast-fn here in order to correctly cache out-of-range
+                   ;;issues with types like uint8
+                   (readLong [rdr idx] (cast-fn (.readLong src-rdr idx))))
+                 (and number? (identical? simp-op-space :float64))
                  (reify DoubleReader
                    (elemwiseDatatype [rdr] new-dtype)
                    (lsize [rdr] (.lsize src-rdr))
-                   (readDouble [rdr idx] (.readDouble src-rdr idx))))
-               (let [src-rdr (->reader item)]
+                   (readDouble [rdr idx] (.readDouble src-rdr idx)))
+                 :else
                  (reify ObjectReader
                    (elemwiseDatatype [rdr] new-dtype)
                    (lsize [rdr] (.lsize src-rdr))

src/tech/v3/datatype/casting.clj

@@ -74,15 +74,15 @@
 
 (def float-types #{:float32 :float64})
 
-(def int-types (set (concat (flatten (seq signed-unsigned)) [:char])))
+(def int-types (set (concat (flatten (seq signed-unsigned)))))
 
 (def signed-int-types (set (keys signed-unsigned)))
 
 (def unsigned-int-types (set (vals signed-unsigned)))
 
 (def host-numeric-types (set (concat signed-int-types float-types)))
 
-(def numeric-types (set (concat host-numeric-types unsigned-int-types [:char])))
+(def numeric-types (set (concat host-numeric-types unsigned-int-types)))
 
 
 (defonce valid-datatype-set (atom nil))
@@ -98,7 +98,7 @@
           (->> (concat (keys datatype->class-map)
                        (keys aliased-datatypes)
                        numeric-types
-                       [:object :boolean])
+                       [:object :boolean :char])
                (->hash-set))))
 
 
@@ -167,6 +167,9 @@
             (quot (int-width dtype) 8)
             (float-types dtype)
             (quot (float-width dtype) 8)
+            ;;char is a shitty uint16
+            (identical? dtype :char)
+            (int-width :uint16)
             :else
             (throw (ex-info (format "datatype is not numeric: %s" dtype)
                             {:datatype dtype}))))))

src/tech/v3/datatype/native_buffer.clj

@@ -174,7 +174,8 @@
                              :int64 ['.putLong '.getLong]
                              :float32 ['.putFloat '.getFloat]
                              :float64 ['.putDouble '.getDouble])
-        accum-type (if (casting/integer-type? datatype)
+        accum-type (if (or (= :char datatype)
+                           (casting/integer-type? datatype))
                      :int64
                      :float64)]
     `(do
@@ -267,7 +268,8 @@
              ;;For integer types, everything implements readlong.
              ;;They also implement readX where X maps to exactly the datatype.
              ;;For example byte arrays implement readLong and readByte.
-             (casting/integer-type? datatype)
+             (or (= :char datatype)
+                 (casting/integer-type? datatype))
              (concat
               [`(readLong [rdr# ~'idx]
                           (casting/datatype->unchecked-cast-fn
@@ -320,7 +322,8 @@
              (= :boolean datatype)
              [`(writeBoolean [wtr# idx# ~'value]
                              (write-value ~address ~swap? ~datatype ~byte-width ~n-elems))]
-             (casting/integer-type? datatype)
+             (or (= :char datatype (casting/integer-type? datatype))
+                 (casting/integer-type? datatype))
              (concat
               [`(writeLong [rdr# ~'idx ~'value]
                            (write-value ~address ~swap? ~datatype ~byte-width ~n-elems))]
@@ -354,7 +357,7 @@
               `(writeFloat [rdr# ~'idx ~'value]
                            (write-value ~address ~swap? ~datatype ~byte-width ~n-elems))]
              :else
-             [`(writeObject [wtr# idx# val#]
+             [`(writeObject [wtr# ~'idx ~'value]
                             ;;Writing values is always checked, no options.
                             (write-value ~address ~swap? ~datatype ~byte-width ~n-elems))])))))
 

src/tech/v3/datatype/typecast.clj

@@ -69,7 +69,7 @@
     :boolean 'tech.v3.datatype.BooleanReader
     :int8 'tech.v3.datatype.LongReader
     :int16 'tech.v3.datatype.LongReader
-    :char 'tech.v3.datatype.LongReader
+    :char 'tech.v3.datatype.ObjectReader
     :int32 'tech.v3.datatype.LongReader
     :int64 'tech.v3.datatype.LongReader
     :float32 'tech.v3.datatype.DoubleReader
@@ -82,8 +82,8 @@
   (case (casting/safe-flatten dtype)
     :boolean 'tech.v3.datatype.BooleanWriter
     :int8 'tech.v3.datatype.LongWriter
-    :int16 'tech.v3.datatype.LongtWriter
-    :char 'tech.v3.datatype.LongWriter
+    :int16 'tech.v3.datatype.LongWriter
+    :char 'tech.v3.datatype.ObjectWriter
     :int32 'tech.v3.datatype.LongWriter
     :int64 'tech.v3.datatype.LongWriter
     :float32 'tech.v3.datatype.DoubleWriter

test/tech/v3/datatype_test.clj

@@ -747,3 +747,21 @@
     (is (thrown? Throwable (nth data -11)))
     (is (= :a (nth data -11 :a)))
     (is (= 0 (nth data -10 :a)))))
+
+
+(deftest elemwise-cast-container
+  (let [c (dtype/make-container :float64 [1.2])
+        ic (dtype/elemwise-cast c :int32)]
+    (is (= 1 (ic 0))))
+  (let [c (dtype/make-container :float64 [155])
+        ic (dtype/elemwise-cast c :int8)]
+    (is (thrown? Throwable (ic 0))))
+  (let [c (dtype/make-container :float64 [155])
+        ic (dtype/elemwise-cast c :uint8)]
+    (is (= 155 (ic 0))))
+  ;;This one is tricky because the JVM is too stupid to cast
+  ;;an char, which is an unsigned short, to any numeric type without
+  ;;more magic.
+  (let [c (dtype/make-container :char [155])
+        ic (dtype/elemwise-cast c :uint8)]
+    (is (= 155 (ic 0)))))