Golang gogsl.InitializeGslReference函数代码示例

func DriverAllocScaledNew(sys *GslOdeiv2System, t *GslOdeiv2StepType, hstart float64, epsabs float64, epsrel float64, aY float64, aDydt float64, scaleAbs []float64) *GslOdeiv2Driver {
	_slice_header_7 := (*reflect.SliceHeader)(unsafe.Pointer(&scaleAbs))
	_ref := C.gsl_odeiv2_driver_alloc_scaled_new((*C.gsl_odeiv2_system)(unsafe.Pointer(sys.CPtr())), (*C.gsl_odeiv2_step_type)(unsafe.Pointer(t.Ptr())), C.double(hstart), C.double(epsabs), C.double(epsrel), C.double(aY), C.double(aDydt), (*C.double)(unsafe.Pointer(_slice_header_7.Data)))
	_result := &GslOdeiv2Driver{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func ControlScaledNew(epsAbs float64, epsRel float64, aY float64, aDydt float64, scaleAbs []float64, dim int) *GslOdeiv2Control {
	_slice_header_4 := (*reflect.SliceHeader)(unsafe.Pointer(&scaleAbs))
	_ref := C.gsl_odeiv2_control_scaled_new(C.double(epsAbs), C.double(epsRel), C.double(aY), C.double(aDydt), (*C.double)(unsafe.Pointer(_slice_header_4.Data)), C.size_t(dim))
	_result := &GslOdeiv2Control{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func DiscretePreproc(k int, p []float64) *GslRanDiscreteT {
	_slice_header_1 := (*reflect.SliceHeader)(unsafe.Pointer(&p))
	_ref := C.gsl_ran_discrete_preproc(C.size_t(k), (*C.double)(unsafe.Pointer(_slice_header_1.Data)))
	_result := &GslRanDiscreteT{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

//gsl_ntuple * gsl_ntuple_create (char * filename, void * ntuple_data, size_t size)
func CreateOrOpen(filename string, data interface{}, op OpenOperation) *GslNtuple {

	// Check the data type and make sure it is a slice of some concrete type.
	dataType := reflect.TypeOf(data)
	if dataType.Kind() != reflect.Slice {
		gogsl.Error("ntuple.Create() data argument must be a slice", gogsl.GSL_EINVAL)
		return nil
	}
	dataValue := reflect.ValueOf(data)
	baseType := dataType.Elem()
	dataSize := int(baseType.Size()) * dataValue.Len()
	if !dataValue.CanAddr() {
		x := reflect.New(dataValue.Type()).Elem()
		x.Set(dataValue)
		dataValue = x
	}
	srcHdr := (*reflect.SliceHeader)(unsafe.Pointer(dataValue.UnsafeAddr()))
	cFile := C.CString(filename)
	var tuplePtr *C.gsl_ntuple
	switch op {
	case OPEN:
		{
			tuplePtr = C.gsl_ntuple_open(cFile, unsafe.Pointer(srcHdr.Data), C.size_t(dataSize))
		}
	case CREATE:
		{
			tuplePtr = C.gsl_ntuple_create(cFile, unsafe.Pointer(srcHdr.Data), C.size_t(dataSize))
		}
	default:
		{
			gogsl.Error("unknown open operation", gogsl.GSL_EINVAL)
			return nil
		}
	}
	result := &GslNtuple{baseType: baseType, refLen: dataValue.Len(), elementSize: int(baseType.Size()), ref: data}
	gogsl.InitializeGslReference(result, uintptr(unsafe.Pointer(tuplePtr)))
	C.free(unsafe.Pointer(cFile))
	return result
}

func DriverAllocStandardNew(sys *GslOdeiv2System, t *GslOdeiv2StepType, hstart float64, epsabs float64, epsrel float64, aY float64, aDydt float64) *GslOdeiv2Driver {
	_ref := C.gsl_odeiv2_driver_alloc_standard_new((*C.gsl_odeiv2_system)(unsafe.Pointer(sys.CPtr())), (*C.gsl_odeiv2_step_type)(unsafe.Pointer(t.Ptr())), C.double(hstart), C.double(epsabs), C.double(epsrel), C.double(aY), C.double(aDydt))
	_result := &GslOdeiv2Driver{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func WaveletAlloc(t *GslWaveletType, k int) *GslWavelet {
	_ref := C.gsl_wavelet_alloc((*C.gsl_wavelet_type)(unsafe.Pointer(t.Ptr())), C.size_t(k))
	_result := &GslWavelet{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func Alloc(size int) *GslDht {
	_ref := C.gsl_dht_alloc(C.size_t(size))
	_result := &GslDht{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func BlockComplexCalloc(n int) *GslBlockComplex {
	_ref := C.gsl_block_complex_calloc(C.size_t(n))
	_result := &GslBlockComplex{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func FdfsolverF(s *GslMultirootFdfsolver) *vector.GslVector {
	_ref := C.gsl_multiroot_fdfsolver_f((*C.gsl_multiroot_fdfsolver)(unsafe.Pointer(s.Ptr())))
	_result := &vector.GslVector{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func Clone(q *GslQrng) *GslQrng {
	_ref := C.gsl_qrng_clone((*C.gsl_qrng)(unsafe.Pointer(q.Ptr())))
	_result := &GslQrng{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func ComplexWorkspaceAlloc(n int) *GslFftComplexWorkspace {
	_ref := C.gsl_fft_complex_workspace_alloc(C.size_t(n))
	_result := &GslFftComplexWorkspace{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func HalfcomplexWavetableAlloc(n int) *GslFftHalfcomplexWavetable {
	_ref := C.gsl_fft_halfcomplex_wavetable_alloc(C.size_t(n))
	_result := &GslFftHalfcomplexWavetable{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func ControlYpNew(epsAbs float64, epsRel float64) *GslOdeiv2Control {
	_ref := C.gsl_odeiv2_control_yp_new(C.double(epsAbs), C.double(epsRel))
	_result := &GslOdeiv2Control{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func ControlStandardNew(epsAbs float64, epsRel float64, aY float64, aDydt float64) *GslOdeiv2Control {
	_ref := C.gsl_odeiv2_control_standard_new(C.double(epsAbs), C.double(epsRel), C.double(aY), C.double(aDydt))
	_result := &GslOdeiv2Control{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}

func StepAlloc(t *GslOdeiv2StepType, dim int) *GslOdeiv2Step {
	_ref := C.gsl_odeiv2_step_alloc((*C.gsl_odeiv2_step_type)(unsafe.Pointer(t.Ptr())), C.size_t(dim))
	_result := &GslOdeiv2Step{}
	gogsl.InitializeGslReference(_result, uintptr(unsafe.Pointer(_ref)))
	return _result
}