Pass fortran array of unknown size to julia

When working with Julia, it is common to encounter situations where you need to pass a Fortran array of unknown size to your Julia code. This can be a challenging task, but fortunately, there are several ways to solve this problem. In this article, we will explore three different approaches to tackle this issue.

Approach 1: Using the `ccall` function

The `ccall` function in Julia allows you to call C functions from Julia code. Since Fortran and C have similar memory layouts, you can use this function to pass a Fortran array to Julia. Here’s how you can do it:

# Julia code
function process_fortran_array(array_ptr::Ptr{Float64}, array_size::Csize_t)
    # Access the Fortran array in Julia
    array = unsafe_wrap(Vector{Float64}, array_ptr, array_size)
    
    # Process the array as needed
    # ...
end

# C code
extern "C" void process_fortran_array(double* array_ptr, size_t array_size)
{
    // Call the Julia function
    ccall(:process_fortran_array, Cvoid, (Ptr{Float64}, Csize_t), array_ptr, array_size);
}

In this approach, you define a Julia function that takes a pointer to the Fortran array and its size as arguments. Inside the function, you use the `unsafe_wrap` function to create a Julia array that references the Fortran array’s memory. You can then process the array as needed.

Approach 2: Using the `ccall` function with a wrapper function

If you prefer a more structured approach, you can create a wrapper function in C that takes care of the memory management and calls the Julia function. Here’s an example:

# Julia code
function process_fortran_array(array::Vector{Float64})
    # Process the array as needed
    # ...
end

# C code
extern "C" void process_fortran_array_wrapper(double* array_ptr, size_t array_size)
{
    // Create a Julia array from the Fortran array
    jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1);
    jl_array_t* julia_array = jl_ptr_to_array_1d(array_type, array_ptr, array_size, 0);
    
    // Call the Julia function
    jl_function_t* julia_function = jl_get_function(jl_main_module, "process_fortran_array");
    jl_call1(julia_function, (jl_value_t*)julia_array);
}

In this approach, you create a wrapper function in C that takes the Fortran array and its size as arguments. Inside the wrapper function, you create a Julia array using the `jl_ptr_to_array_1d` function. You then call the Julia function using the `jl_call1` function.

Approach 3: Using the `ccall` function with a Julia struct

If you prefer a more object-oriented approach, you can define a Julia struct that represents the Fortran array and use it to pass the array to Julia. Here’s an example:

# Julia code
struct FortranArray
    array_ptr::Ptr{Float64}
    array_size::Csize_t
end

function process_fortran_array(array::FortranArray)
    # Access the Fortran array in Julia
    julia_array = unsafe_wrap(Vector{Float64}, array.array_ptr, array.array_size)
    
    # Process the array as needed
    # ...
end

# C code
typedef struct {
    double* array_ptr;
    size_t array_size;
} FortranArray;

extern "C" void process_fortran_array(FortranArray* array)
{
    // Call the Julia function
    ccall(:process_fortran_array, Cvoid, (FortranArray,), array);
}

In this approach, you define a Julia struct that represents the Fortran array. The struct has two fields: `array_ptr`, which is a pointer to the array, and `array_size`, which is the size of the array. You can then pass an instance of this struct to the Julia function using the `ccall` function.

After exploring these three approaches, it is clear that the best option depends on your specific use case. If you prefer a low-level approach with direct memory access, Approach 1 using the `ccall` function is a good choice. If you prefer a more structured approach with separate C and Julia code, Approach 2 with a wrapper function is a good option. Finally, if you prefer an object-oriented approach, Approach 3 with a Julia struct is the way to go. Choose the option that best suits your needs and enjoy passing Fortran arrays of unknown size to your Julia code!