int square(double a[],double b[]) { // Init Julia jl_init_with_image("/Users/fgans/julia/julia-4d1b751dda/lib/julia", "sys.ji"); JL_SET_STACK_BASE; // Define Array Type for 1D Array jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1); // Connect C-Arrays to julia Arrays jl_array_t *a_jl = jl_ptr_to_array_1d(array_type, a, 1, 0); jl_array_t *b_jl = jl_ptr_to_array_1d(array_type, b, 1, 0); // Load julia code jl_eval_string("include(\"square.jl\")"); // Get function jl_function_t *func = jl_get_function(jl_main_module, "square"); if (func==NULL) { printf("Function not found!\n"); return -1; } // Apply function jl_call2(func, (jl_value_t*)a_jl,(jl_value_t*)b_jl); if (jl_exception_occurred()) printf("%s \n", jl_typeof_str(jl_exception_occurred())); return 0; }
static jl_value_t *from_td_val(td_val_t *v) { td_tag_t tag = td_typeof(v); switch (tag) { case TD_INT8: return jl_box_int8(td_int8(v)); case TD_UINT8: return jl_box_uint8(td_uint8(v)); case TD_INT16: return jl_box_int16(td_int16(v)); case TD_UINT16: return jl_box_uint16(td_uint16(v)); case TD_INT32: return jl_box_int32(td_int32(v)); case TD_UINT32: return jl_box_uint32(td_uint32(v)); case TD_INT64: return jl_box_int64(td_int64(v)); case TD_UINT64: return jl_box_uint64(td_uint64(v)); case TD_FLOAT: return jl_box_float32(td_float(v)); case TD_DOUBLE: return jl_box_float64(td_double(v)); case TD_UTF8: return jl_pchar_to_string(td_dataptr(v), td_length(v)); case TD_ARRAY: return (jl_value_t*) jl_ptr_to_array_1d((jl_value_t*)jl_apply_array_type((jl_datatype_t*)td_type_to_jl(td_eltype(v)), 1), td_dataptr(v), td_length(v), 0); default: return jl_nothing; } }
void juliaProblem::EucHessianEta(Variable *x, Vector *etax, Vector *exix) const { // x->Print("cpp hf x");//--- // etax->Print("cpp hf etax");//--- jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1); double *xptr = x->ObtainWritePartialData(); jl_array_t *arrx = jl_ptr_to_array_1d(array_type, xptr, x->Getlength(), 0); double *etaxptr = etax->ObtainWritePartialData(); jl_array_t *arretax = jl_ptr_to_array_1d(array_type, etaxptr, etax->Getlength(), 0); jl_array_t *arrtmp = nullptr; if(x->TempDataExist(("Tmp"))) { const SharedSpace *Tmp = x->ObtainReadTempData("Tmp"); // Tmp->Print("cpp hf inTmp");//--- const double *tmpptr = Tmp->ObtainReadData(); arrtmp = jl_ptr_to_array_1d(array_type, const_cast<double *> (tmpptr), Tmp->Getlength(), 0); } else { arrtmp = jl_ptr_to_array_1d(array_type, nullptr, 0, 0); } jl_value_t *retresult = jl_call3(jl_Hess, (jl_value_t *) arrx, (jl_value_t *) arrtmp, (jl_value_t *) arretax); jl_array_t *jl_exix = (jl_array_t *) jl_get_nth_field(retresult, 0); jl_array_t *outtmp = (jl_array_t *) jl_get_nth_field(retresult, 1); if(jl_array_len(jl_exix) != etax->Getlength()) { std::cout << "error: the size of the action of the Hessian is not correct!" << std::endl; exit(EXIT_FAILURE); } integer exixlen = exix->Getlength(); double *exixptr = exix->ObtainWriteEntireData(); dcopy_(&exixlen, (double*)jl_array_data(jl_exix), &GLOBAL::IONE, exixptr, &GLOBAL::IONE); // exix->Print("cpp hf exix:");//--- integer outtmplen = jl_array_len(outtmp); if(outtmplen != 0) { SharedSpace *sharedouttmp = new SharedSpace(1, outtmplen); double *outtmpptr = sharedouttmp->ObtainWriteEntireData(); dcopy_(&outtmplen, (double*)jl_array_data(outtmp), &GLOBAL::IONE, outtmpptr, &GLOBAL::IONE); x->RemoveFromTempData("Tmp"); x->AddToTempData("Tmp", sharedouttmp); } };
JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data, jl_value_t *_dims, int own_buffer) { jl_ptls_t ptls = jl_get_ptls_states(); size_t elsz, nel = 1; jl_array_t *a; size_t ndims = jl_nfields(_dims); wideint_t prod; assert(is_ntuple_long(_dims)); size_t *dims = (size_t*)_dims; for (size_t i = 0; i < ndims; i++) { prod = (wideint_t)nel * (wideint_t)dims[i]; if (prod > (wideint_t) MAXINTVAL) jl_error("invalid Array dimensions"); nel = prod; } if (__unlikely(ndims == 1)) return jl_ptr_to_array_1d(atype, data, nel, own_buffer); jl_value_t *el_type = jl_tparam0(atype); int isunboxed = store_unboxed(el_type); if (isunboxed) elsz = jl_datatype_size(el_type); else elsz = sizeof(void*); int ndimwords = jl_array_ndimwords(ndims); int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT); a = (jl_array_t*)jl_gc_alloc(ptls, tsz, atype); // No allocation or safepoint allowed after this a->flags.pooled = tsz <= GC_MAX_SZCLASS; a->data = data; #ifdef STORE_ARRAY_LEN a->length = nel; #endif a->elsize = elsz; a->flags.ptrarray = !isunboxed; a->flags.ndims = ndims; a->offset = 0; a->flags.isshared = 1; a->flags.isaligned = 0; if (own_buffer) { a->flags.how = 2; jl_gc_track_malloced_array(ptls, a); jl_gc_count_allocd(nel*elsz + (elsz == 1 ? 1 : 0)); } else { a->flags.how = 0; } assert(ndims != 1); // handled above memcpy(&a->nrows, dims, ndims * sizeof(size_t)); return a; }
ValueIfNotPtrArray<T> boxArray(T* data, size_t size) { log("boxArray(T*) - jl_ptr_to_array_1d"); jl_datatype_t* dataType = TypeTraits<UnqualifiedType<T>>::dataType(); JULIACPP_ASSERT(dataType != nullptr, "Data type not supported."); jl_value_t* arrayType = jl_apply_array_type(dataType, 1); jl_array_t* array = jl_ptr_to_array_1d(arrayType, data, size, 0); return (jl_value_t*)array; }
double juliaProblem::f(Variable *x) const { // x->Print("cpp f x");//--- jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1); double *xptr = x->ObtainWritePartialData(); jl_array_t *arrx = jl_ptr_to_array_1d(array_type, xptr, x->Getlength(), 0); jl_array_t *arrtmp = nullptr; if(x->TempDataExist(("Tmp"))) { const SharedSpace *Tmp = x->ObtainReadTempData("Tmp"); const double *tmpptr = Tmp->ObtainReadData(); arrtmp = jl_ptr_to_array_1d(array_type, const_cast<double *> (tmpptr), Tmp->Getlength(), 0); } else { arrtmp = jl_ptr_to_array_1d(array_type, nullptr, 0, 0); } jl_value_t *retresult = jl_call2(jl_f, (jl_value_t *) arrx, (jl_value_t *) arrtmp); jl_get_nth_field(retresult, 0); jl_value_t *fx = jl_get_nth_field(retresult, 0); jl_array_t *outtmp = (jl_array_t *) jl_get_nth_field(retresult, 1); integer outtmplen = jl_array_len(outtmp); SharedSpace *sharedouttmp = new SharedSpace(1, outtmplen); double *outtmpptr = sharedouttmp->ObtainWriteEntireData(); dcopy_(&outtmplen, (double*)jl_array_data(outtmp), &GLOBAL::IONE, outtmpptr, &GLOBAL::IONE); // sharedouttmp->Print("cpp f tmp:");//---- x->RemoveFromTempData("Tmp"); x->AddToTempData("Tmp", sharedouttmp); if(jl_is_float64(fx)) { double result = jl_unbox_float64(fx); // std::cout << "cpp f fx:" << result << std::endl;//----- return result; } std::cout << "Error: The objectve function must return a number of double precision!" << std::endl; exit(EXIT_FAILURE); };
jl_array_t *jl_takebuf_array(ios_t *s) { size_t n; jl_array_t *a; if (s->buf == &s->local[0]) { // small data case. copies, but this can be avoided using the // technique of jl_readuntil below. a = jl_pchar_to_array(s->buf, s->size); ios_trunc(s, 0); } else { char *b = ios_takebuf(s, &n); a = jl_ptr_to_array_1d(jl_array_uint8_type, b, n-1, 1); } return a; }