Accessing Singular from Julia

using Cxx

const singdir = "/home/wbhart/singular-4/T/home/wbhart/singular-4/"

addHeaderDir(joinpath(singdir, "include"), kind = C_System)

addHeaderDir(joinpath(singdir, "include/singular"), kind = C_System)

cxxinclude("Singular/libsingular.h", isAngled=false)

dlopen(joinpath(singdir, "lib/libSingular.so"), RTLD_GLOBAL)

@cxx siInit(pointer(joinpath(singdir, "bin/Singular")))

Here is my idea for Julia wrappers for Singular "pointer" types (all of low level element types: number, poly, ideal) which are to be treated in conjunction with corresponding management objects (coeffs, ring):

abstract SingularCoeffs
type SingularQQ <: SingularCoeffs end
type SingularZZ <: SingularCoeffs end
bitstype WORD_SIZE GenericSingularCoeffs  <: SingularCoeffs

abstract SingularNumber <: Number
bitstype WORD_SIZE GenericSingularNumber{Coeffs <: SingularCoeffs}  <: SingularNumber

InitSingularNumber{Coeffs <: SingularCoeffs}( ::Type{Coeffs}, i) = reinterpret(GenericSingularNumber{Coeffs}, i)

InitSingularNumber( SingularQQ, 2 ) # GenericSingularNumber{SingularQQ}(0x0000000000000002)
isbits(ans) # true


function myop{C}( a::GenericSingularNumber{C}, b::GenericSingularNumber{C} )
  println( "myop ($a, $b) over $C")
end

myop( InitSingularNumber( SingularQQ, 22 ), InitSingularNumber( SingularQQ, 66 ) )
myop (GenericSingularNumber{SingularQQ}(0x0000000000000016), GenericSingularNumber{SingularQQ}(0x0000000000000042)) over SingularQQ

myop( InitSingularNumber( SingularZZ, 22 ), InitSingularNumber( SingularZZ, 66 ) )
myop (GenericSingularNumber{SingularZZ}(0x0000000000000016), GenericSingularNumber{SingularZZ}(0x0000000000000042)) over SingularZZ

myop( InitSingularNumber( SingularQQ, 22 ), InitSingularNumber( SingularZZ, 66 ) ) 
# ERROR: `myop` has no method matching myop(::GenericSingularNumber{SingularQQ}, ::GenericSingularNumber{SingularZZ})

myop( InitSingularNumber( SingularZZ, 22 ), InitSingularNumber( SingularQQ, 66 ) ) 
# ERROR: `myop` has no method matching myop(::GenericSingularNumber{SingularZZ}, ::GenericSingularNumber{SingularQQ})

Pros:

• we avoid one extra level of indirection (types in Julia are pointers to heap allocated things)
• we can specialize conversions to/from Julia Number types to specific Singular Numbers

Cons:

• we need to do "proper" construction/destruction for all such handles "by hand"

Proof of concept:

using Cxx
cxx"""
typedef void* SingularCoeffs;
typedef void* SingularNumber;
SingularNumber InitSingularNumber( SingularCoeffs cf, unsigned long i )
{ i += (unsigned long)(cf); return (SingularNumber)(i); } 
"""

@cxx InitSingularNumber( Ptr{Void}(1), 2) # Ptr{Void} @0x0000000000000003