Add some documentation ?

[BambOoxX]

Hey, I'm really looking forward to testing this piece of software. I've waited for a julia / .NET interface for pretty long and I'd like to help improving it, though I am pretty sure I cannot help much on the coding side.

My main use case currently consists in having a .NET developped GUI using data computed in julia. Currently this is done via RPC but I really would like to avoid that if possible.

The main information I am missing right now about JdotNet is

• Is it possible to retrieve the exported types in a given module in julia in the .NET side ? When doing RPC, one has to write the type definitions on both sides making development a bit harder.
• How do you use function with complex signatures (multiple arguments, types ...)
• How do you start a persistent julia session (basically as long a a GUI exists) and close it cleanly / keep track of things ?
• Not sure I really understood the role of the Any type ? Could you clarify that ?

[HyperSphereStudio]

I apologize I am in College at the moment so my work on this prpject is intermitten.

Many Julia commands are found in the class Julia. To launch a julia session, you use Julia.Init. If you want to launch julia using custom options (such as from ing, threads, other .exe of julia) there is overload constructor.

To kill a session use .Exit

You can only create one session of Julia per lifetime of an AppDomain

The Any type in JDotNet represents any value that is allocated in Julia. For immutable types (and other special values like string) it will copy it and allocate it in julia.

For mutable types it create a reference of this value in Julia. (Arrays for instance). Julia is allowed to mutate the sharp mutable object.

Note that there is some exceptions to this

[BambOoxX]

Also, is the row-major / column-major array indexing modified in any manner, how is it handled ?

[HyperSphereStudio]

I handled the column-row/major problem by having c# arrays passed into julia through a lazy multidimensional transpose.

So it will have the same behaviour (will be a bit slower if your doing alot of element by element operations though since it has to transform the indices each operation)

[HyperSphereStudio]

I still have trouble understanding how things happen (generally not specifically to JdotNET), does that mean that a variable with the following type signature

struct MyType
    arr::Array{Float64,3}
end

would be passed by value, or by reference ? A bit of both ?

So this is more of the inner workings of julia rather then the library specfically. In order to create a Any object, I HAVE to allocate memory on the heap and box it so I know the type. So what I am passing around csharp with the Any type is a reference to the boxed object. However the value itself is immutable and not a reference type. Like I cant alter the value of an any type of this value and expect to see the change in julia

[HyperSphereStudio]

I still have trouble understanding how things happen (generally not specifically to JdotNET), does that mean that a variable with the following type signature

struct MyType
    arr::Array{Float64,3}
end

would be passed by value, or by reference ? A bit of both ?

So this is more of the inner workings of julia rather then the library specfically. In order to create a Any object, I HAVE to allocate memory on the heap and box it so I know the type. So what I am passing around csharp with the Any type is a reference to the boxed object. However the value itself is immutable and not a reference type. Like I cant alter the value of an any type of this value and expect to see the change in julia

A little bit more on this question

As the Static Library generator becomes more sophisticated (tbh you may actually literally be able to use my Julia-Sharp runtime for this instead since this is literally what it is specialized to do) you will be able to represent raw julia types on terms of sharp types. Meaning you wont have any conversion overhead for many things also meaning that you wont have to go through boxing and unboxing etc.

My Spinor programming language is being designed to take in Julia code and spit out a .net DLL that has the .NET representation of the julia code. Now its not really meant to be run from CSharp at the moment so it would be a bit weird but not impossible

[BambOoxX]

As the Static Library generator becomes more sophisticated (tbh you may actually literally be able to use my Julia-Sharp runtime for this instead since this is literally what it is specialized to do)

Could you be more specific on the "specialised to do" part?

In my use case, I use Julia because it really has a science touch through a lot of interesting packages, and the syntax feels much easier to understand that python's.
For most of the time I do not need. Net at all. I can do all the science part with just Julia.
The. Net part ist the cherry on top. I have a workable Julia part but with a nice stable interface.

To sum it up I do not want to perform all of my work in. Net because that feels too heavy. But being able to leverage some homecooked Julia with a. Net gui, now that hits the spot!

[HyperSphereStudio]

Julia Function:

A julia function is a collection of julia methods. Each method has a unique type tuple representing the arguments.

When you use the "GetFunction" from a module, it will return to you a function handle. Calling Invoke will internally observe the types of the arguments and select the proper method and invoke it based on the rules of julias calling convention. This can be slow so refer to the readme on how to select a single method and compile it to a sharp function handle if its called frequently.

[BambOoxX]

Taking the example in the readme (I assume you are talking about this part)

//Native Pointer of Specialized Methods. (FASTEST) This is unsafe so you should periodically check for exceptions
    var f = Julia.Eval(@"add(a, b) = a + b");   //Gets the julia function pointer add
    
    public delegate int Add(int a, int b); /*Declared somewhere*/
    
    Add add = f.GetDelegate<Add>();             //Compile f to a sharp function pointer Add
    var aAdd = f.GetDelegate<int, int, int>(); 

I see multiple things here (correct me if any are wrong)

• You can evaluate on the fly a julian expression with Julia.Eval, but I'm guessing that as in direct julia, eval-ing stuff is not the best thing to do in a general manner (AFAIK)
• Declaring the Add delegate and "getting" this delegate from a function is a way to specify the method (in julian terms) of the function that one actually wants to use. However this requires that for a function with custom types, one declares the required input and output types in C#

[HyperSphereStudio]

Yeah the eval thing shouldnt really be used in production code at all. What you should do instead is create a file with a script and call Julia.include on it instead.

You dont have to know the signature ahead of hand in csharp to call a function. Only if you want to isolate a specific method and have a direct embedded link to it. (ie it will have essentially the same call overhead as any normal function being called since it completely skips over all type checking and literally directly invokes it using normal calling conventions)