Merge pull request #23 from Clonkk/devel

Devel

Author: Clonkk

changelog.md

@@ -1,5 +1,10 @@
 Changelog for Nimjl. Date in format YYYY_MM_DD
 
+Release v0.5.3 - 2021_06_24
+===========================
+* Improve file layout
+* Added object <=> struct conversions
+
 Release v0.5.2 - 2021_05_25
 ===========================
 * Split tests into multiple files
@@ -26,7 +31,7 @@ Release v0.4.5 - 2021_04_02
 
 Release v0.4.4 - 2021_03_25
 ===========================
-* Add support for Option 
+* Add support for Option
 * Fix boxing bool and voidpointer types
 * Improve test coverage
 * Add examples to ci
@@ -46,7 +51,7 @@ Release v0.4.1 - 2021_03_10
 * Add seq support when converting types
 * Add Tensor support when converting types
 * Improved dispatch using generic proc instead of ``when T is ...``
-* Format code using nimpretty 
+* Format code using nimpretty
 * Add changelog
 * Improve readme
 * Improve examples

nimjl.nim

@@ -1,27 +1,25 @@
-import nimjl/arrays
+import ./nimjl/arrays
 export arrays
 
-import nimjl/cores
+import ./nimjl/cores
 export cores
 
-import nimjl/types
+import ./nimjl/types
 export types
 
-import nimjl/gc
+import ./nimjl/gc
 export gc
 
-import nimjl/functions
+import ./nimjl/functions
 export functions
 
-import nimjl/glucose
+import ./nimjl/glucose
 export glucose
 
-import nimjl/sugar/converttypes
-export converttypes
+import ./nimjl/conversions
+export conversions
 
-import nimjl/sugar/valindexing
-export valindexing
+import ./nimjl/config
 
-import nimjl/config
 static:
   debugEcho "Nimjl> Using Julia install: ", JuliaPath

nimjl.nimble

@@ -1,14 +1,14 @@
 # Nimjl
 # Licensed and distributed under MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT).
-version       = "0.5.2"
+version       = "0.5.3"
 author        = "Regis Caillaud"
 description   = "Nim Julia bridge"
 license       = "MIT"
 # installDirs   = @["third_party", "install"]
 
 # Dependencies
 requires "nim >= 1.2.0"
-requires "arraymancer"
+requires "arraymancer >= 0.6.3"
 
 # TODO finish auto installation of Julia
 task installjulia, "Install Julia":

nimjl/arrays.nim

@@ -5,7 +5,6 @@ import ./functions
 
 import arraymancer
 
-import std/typetraits
 import std/sequtils
 
 proc toJlArray*[T](x: JlValue): JlArray[T] {.inline.} =
@@ -46,8 +45,11 @@ proc jlArrayFromBuffer*[T](data: openArray[T]): JlArray[T] =
   result = jlArrayFromBuffer(uncheckedDataPtr, [data.len()])
 
 proc jlArrayFromBuffer*[T](data: Tensor[T]): JlArray[T] =
+  if not data.is_contiguous:
+    raise newException(ValueError, "Error using non-contiguous Tensor as buffer")
+
   ## Create an Array from existing buffer
-  let uncheckedDataPtr = data.unsafe_raw_offset().distinctBase()
+  let uncheckedDataPtr = data.toUnsafeView()
   result = jlArrayFromBuffer(uncheckedDataPtr, data.shape.toSeq)
 
 # Julia allocated array

nimjl/arrays/indexing.nim

@@ -24,7 +24,7 @@ proc makerange[T](x: JlArray[T], start, stop: int): JlValue =
 
 # This comes from arraymancer
 # |2 syntax is parsed but not used for now
-macro desugar*[T](x: JlArray[T], args: untyped): void =
+macro desugar[T](x: JlArray[T], args: untyped): void =
   ## Transform all syntactic sugar in arguments to integer or slices
 
   # echo "\n------------------\nOriginal tree"

nimjl/arrays/interop.nim

@@ -97,10 +97,10 @@ proc toJlArray*[T: seq|array](oa: openarray[T]): auto =
     inc(i)
 
 # Utility
-proc firstindex*[T](val: JlArray[T], dim: int) : int =
+proc firstindex*[T](val: JlArray[T], dim: int): int =
   jlCall("firstindex", val, dim).to(int)
 
-proc lastindex*[T](val: JlArray[T], dim: int) : int =
+proc lastindex*[T](val: JlArray[T], dim: int): int =
   jlCall("lastindex", val, dim).to(int)
 
 proc iterate*[T](val: JlArray[T]): JlValue =
@@ -111,32 +111,32 @@ proc iterate*[T](val: JlArray[T]): JlValue =
 proc iterate*[T](val: JlArray[T], state: JlValue): JlValue =
   result = jlCall("iterate", val, state)
 
-proc transpose*[T](x: JlArray[T]) : JlArray[T] =
+proc transpose*[T](x: JlArray[T]): JlArray[T] =
   result = jlCall("transpose", x).toJlArray(T)
 
-proc reshape*[T](x: JlArray[T], dims: JlArray[int]) : JlArray[T] =
+proc reshape*[T](x: JlArray[T], dims: JlArray[int]): JlArray[T] =
   result = jlCall("reshape", x, dims).toJlArray(T)
 
-proc reshape*[T](x: JlArray[T], dims: openarray[int]) : JlArray[T] =
+proc reshape*[T](x: JlArray[T], dims: openarray[int]): JlArray[T] =
   result = jlCall("reshape", x, dims).toJlArray(T)
 
-proc reverse*[T](x: JlArray[T]) : JlArray[T] =
+proc reverse*[T](x: JlArray[T]): JlArray[T] =
   result = jlCall("reverse", x).toJlArray(T)
 
-proc fill*[T](x: T, dims: varargs[int]) : JlArray[T] =
+proc fill*[T](x: T, dims: varargs[int]): JlArray[T] =
   if dims.len > 0:
     result = jlCall("fill", x, dims).toJlArray(T)
   else:
     result = jlCall("fill", x).toJlArray(T)
 
 # TODO map typedesc to Julia type
-proc asType*[T](x: JlArray[T], U: typedesc) : JlArray[U] =
+proc asType*[T](x: JlArray[T], U: typedesc): JlArray[U] =
   let tmp = newSeq[U](1).toJlArray()
   result = jlCall("convert", jltypeof(tmp), x).toJlArray(U)
 
-proc swapMemoryOrder*[T](x: JlArray[T]) : JlArray[T] =
+proc swapMemoryOrder*[T](x: JlArray[T]): JlArray[T] =
   let revshape = reverse(size(x))
-  var invdim : seq[int]
+  var invdim: seq[int]
   for i in countdown(ndims(x), 1):
     invdim.add i
   let tmp = reshape(x, revshape)

nimjl/config.nim

@@ -13,7 +13,10 @@ const JuliaLibPath* = JuliaPath / "lib"
 const JuliaDepPath* = JuliaPath / "lib" / "julia"
 
 const JlVersionCmd = JuliaPath / "bin" / "julia" & " -E VERSION"
-const JuliaVersion = gorge(JlVersionCmd).split("\"")[1].split(".")
+const (cmdOutput, exitCode) = gorgeEx(JlVersionCmd)
+const JuliaVersion = cmdOutput.split("\"")[1].split(".")
+static: doAssert(exitCode == 0, "Julia executable could not be found")
+
   # For release : result has the form ["v", "1.6.0", ""] -> splitting [1] yiels ["1", "6, "0"]
   # For dev: result has the form ["v", "1.7.0-DEV", "667"] -> splitting [1] yiels ["1", "7, "0-DEV", "667"]
 const JuliaMajorVersion* = JuliaVersion[0].parseInt
@@ -32,9 +35,9 @@ const JuliaLibName* = JuliaLibPath / libPrefix & "julia" & libSuffix
 {.passL: "-Wl,-rpath," & JuliaDepPath.}
 {.passL: "-ljulia".}
 
-# Workaround for Julia 1.6.0 and 1.6.1
+# Workaround for Julia 1.6.0
 # See https://github.com/JuliaLang/julia/issues/40524
-when (JuliaMajorVersion, JuliaMinorVersion) == (1, 6) and (JuliaPatchVersion == 0 or JuliaPatchVersion == 1):
-  const internalJuliaLibName* = JuliaDepPath / libPrefix & "Julia-internal" & libSuffix
+when (JuliaMajorVersion, JuliaMinorVersion) == (1, 6):
+  const internalJuliaLibName* = JuliaDepPath / libPrefix & "julia-internal" & libSuffix
   {.passL: "-ljulia-internal".}
 

nimjl/conversions.nim

@@ -0,0 +1,18 @@
+import conversions/fromjl
+import conversions/unbox
+
+import conversions/tojl
+import conversions/box
+
+import conversions/dict_tuples
+import conversions/obj_structs
+
+export fromjl
+export unbox
+
+export tojl
+export box
+
+export dict_tuples
+export obj_structs
+

nimjl/conversions/box.nim

@@ -0,0 +1,40 @@
+import ../private/jlcores
+import ../private/jlboxunbox
+
+import ../types
+
+{.push inline.}
+
+## Box
+proc julia_box(x: int8): JlValue = jl_box_int8(x)
+proc julia_box(x: int16): JlValue = jl_box_int16(x)
+proc julia_box(x: int32): JlValue = jl_box_int32(x)
+proc julia_box(x: int64): JlValue = jl_box_int64(x)
+proc julia_box(x: uint8): JlValue = jl_box_uint8(x)
+proc julia_box(x: uint16): JlValue = jl_box_uint16(x)
+proc julia_box(x: uint32): JlValue = jl_box_uint32(x)
+proc julia_box(x: uint64): JlValue = jl_box_uint64(x)
+proc julia_box(x: float32): JlValue = jl_box_float32(x)
+proc julia_box(x: float64): JlValue = jl_box_float64(x)
+
+proc julia_box(x: int): JlValue =
+  when sizeof(int) == sizeof(int64):
+    jl_box_int64(x)
+  else:
+    jl_box_int32(x)
+
+proc julia_box(x: uint): JlValue =
+  when sizeof(uint) == sizeof(uint64):
+    jl_box_uint64(x)
+  else:
+    jl_box_uint32(x)
+
+proc julia_box(x: bool): JlValue = jl_box_bool(x)
+proc julia_box(x: pointer): JlValue = jl_box_voidpointer(x)
+
+{.pop.}
+
+proc jlBox*[T](val: T): JlValue =
+  julia_box(val)
+
+

nimjl/sugar/dicttuples.nim nimjl/conversions/dict_tuples.nimnimjl/sugar/dicttuples.nim renamed to nimjl/conversions/dict_tuples.nim

@@ -1,20 +1,22 @@
-import ../cores
 import ../types
 import ../functions
+import ../cores
 
 import std/tables
 import std/strutils
 import std/strformat
 
 proc jlTupleToNim*(val: JlValue, tup: var tuple) =
-  # collect(keys(val))
+  # julia> collect(keys(val))
   var keys = jlCall("keys", val)
   keys = jlCall("collect", keys)
+
   # Tuple of JlSymbol
-  # length(collect(keys(val)))
+  # julia> length(collect(keys(val)))
   var show = getJlFunc("show")
   var sprint = getJlFunc("sprint")
   var nkeys = jlCall("length", keys).to(int)
+
   var i = 0
   for name, field in tup.fieldPairs:
     inc(i)
@@ -33,31 +35,28 @@ proc jlTupleToNim*(val: JlValue, tup: var tuple) =
       raise newException(JlError, "Tuple conversion from Julia to Nim failed ! Fields must identical")
 
 proc jlDictToNim*[U, V: string|SomeNumber|bool](val: JlValue, tab: var Table[U, V]) =
-  # collect(keys(val))
+  # julia> collect(keys(val))
   var keys = jlCall("keys", val)
   keys = jlCall("collect", keys)
+
   # Tuple of JlSymbol
-  # length(collect(keys(val)))
+  # julia> length(collect(keys(val)))
   var nkeys = jlCall("length", keys).to(int)
   for i in 1..nkeys:
     var key = jlCall("getindex", keys, i)
     var val = jlCall("getindex", val, key)
     tab[key.to(U)] = val.to(V)
 
-# Recursive import strategy
-import ./converttypes
-# Tuple helpers -> result is memory managed by Julia's GC
-# Convert object as tuple ?
 proc nimToUnnamedJlTuple(v: tuple): JlValue =
   var tupStr = $v
   result = jlEval(tupStr)
 
-proc nimToNamedJlTuple(v: tuple|object): JlValue =
+proc nimToNamedJlTuple*(v: tuple|object): JlValue =
   result = jlEval("NamedTuple()")
   for name, field in v.fieldPairs:
-    result = jlCall(JlBase, "setindex", result, toJlVal(field), jlSym(name))
+    result = jlCall(JlBase, "setindex", result, field, jlSym(name))
 
-proc isNamedTuple(v: tuple) : bool =
+proc isNamedTuple(v: tuple): bool =
   var i = 0
   for name, field in v.fieldPairs:
     if name != &"Field{i}":
@@ -71,11 +70,7 @@ proc nimToJlTuple*(v: tuple): JlValue =
   else:
     nimToUnnamedJlTuple(v)
 
-proc nimToJlTuple*(v: object): JlValue =
-  nimToNamedJlTuple(v)
-
 proc nimTableToJlDict*[U, V: string|SomeNumber](tab: Table[U, V]): JlValue =
   result = jlEval("Dict()")
   for name, field in tab:
-    discard jlCall(JlBase, "setindex!", result, toJlVal(field), name)
-
+    discard jlCall(JlBase, "setindex!", result, field, name)