static void
TYPE (copy_jacobian_raw) (double *cmpl, double *real, size_t n, size_t p,
size_t mult, bool inverse)
{
gsl_vector_view dview, sview;
double *cp, *rp;
size_t k, nu;
for (nu = 0; nu < mult; nu++)
{
cp = cmpl + nu;
rp = real + p*nu;
for (k = 0; k < p; k++, rp += 1, cp += mult)
{
dview = gsl_vector_view_array_with_stride (cp, mult * p, n);
sview = gsl_vector_view_array_with_stride (rp, mult * p, n);
if (inverse)
gsl_vector_memcpy (& sview.vector, & dview.vector);
else
gsl_vector_memcpy (& dview.vector, & sview.vector);
}
}
}
bool Vector::gslInit ( const size_t dims, double *base, const size_t stride ) {
bool invalidates
= base != vector.data
|| dims < countDimensions()
|| ( stride != vector.stride && 1 < countDimensions() );
// Circumvent GSL limitation to allow 0-dimensional vectors
if ( 0 == dims ) {
assert( 0 <= stride );
vector.data = base;
vector.size = dims;
vector.stride = stride;
} else {
*static_cast<gsl_vector_view*>( this ) = gsl_vector_view_array_with_stride( base, stride, dims );
}
return invalidates;
}
int
gsl_bspline_knots_greville (const gsl_vector *abscissae,
gsl_bspline_workspace *w,
double *abserr)
{
int s;
/* Check incoming arguments satisfy mandatory algorithmic assumptions */
if (w->k < 2)
GSL_ERROR ("w->k must be at least 2", GSL_EINVAL);
else if (abscissae->size < 2)
GSL_ERROR ("abscissae->size must be at least 2", GSL_EINVAL);
else if (w->nbreak != abscissae->size - w->k + 2)
GSL_ERROR ("w->nbreak must equal abscissae->size - w->k + 2", GSL_EINVAL);
if (w->nbreak == 2)
{
/* No flexibility in abscissae values possible in this degenerate case */
s = gsl_bspline_knots_uniform (
gsl_vector_get (abscissae, 0),
gsl_vector_get (abscissae, abscissae->size - 1), w);
}
else
{
double * storage;
gsl_matrix_view A;
gsl_vector_view tau, b, x, r;
size_t i, j;
/* Constants derived from the B-spline workspace and abscissae details */
const size_t km2 = w->k - 2;
const size_t M = abscissae->size - 2;
const size_t N = w->nbreak - 2;
const double invkm1 = 1.0 / w->km1;
/* Allocate working storage and prepare multiple, zero-filled views */
storage = (double *) calloc (M*N + 2*N + 2*M, sizeof (double));
if (storage == 0)
GSL_ERROR ("failed to allocate working storage", GSL_ENOMEM);
A = gsl_matrix_view_array (storage, M, N);
tau = gsl_vector_view_array (storage + M*N, N);
b = gsl_vector_view_array (storage + M*N + N, M);
x = gsl_vector_view_array (storage + M*N + N + M, N);
r = gsl_vector_view_array (storage + M*N + N + M + N, M);
/* Build matrix from interior breakpoints to interior Greville abscissae.
* For example, when w->k = 4 and w->nbreak = 7 the matrix is
* [ 1, 0, 0, 0, 0;
* 2/3, 1/3, 0, 0, 0;
* 1/3, 1/3, 1/3, 0, 0;
* 0, 1/3, 1/3, 1/3, 0;
* 0, 0, 1/3, 1/3, 1/3;
* 0, 0, 0, 1/3, 2/3;
* 0, 0, 0, 0, 1 ]
* but only center formed as first/last breakpoint is known.
*/
for (j = 0; j < N; ++j)
for (i = 0; i <= km2; ++i)
gsl_matrix_set (&A.matrix, i+j, j, invkm1);
/* Copy interior collocation points from abscissae into b */
for (i = 0; i < M; ++i)
gsl_vector_set (&b.vector, i, gsl_vector_get (abscissae, i+1));
/* Adjust b to account for constraint columns not stored in A */
for (i = 0; i < km2; ++i)
{
double * const v = gsl_vector_ptr (&b.vector, i);
*v -= (1 - (i+1)*invkm1) * gsl_vector_get (abscissae, 0);
}
for (i = 0; i < km2; ++i)
{
double * const v = gsl_vector_ptr (&b.vector, M - km2 + i);
*v -= (i+1)*invkm1 * gsl_vector_get (abscissae, abscissae->size - 1);
}
/* Perform linear least squares to determine interior breakpoints */
s = gsl_linalg_QR_decomp (&A.matrix, &tau.vector)
|| gsl_linalg_QR_lssolve (&A.matrix, &tau.vector,
&b.vector, &x.vector, &r.vector);
if (s)
{
free (storage);
return s;
}
/* "Expand" solution x by adding known first and last breakpoints. */
x = gsl_vector_view_array_with_stride (
gsl_vector_ptr (&x.vector, 0) - x.vector.stride,
x.vector.stride, x.vector.size + 2);
gsl_vector_set (&x.vector, 0, gsl_vector_get (abscissae, 0));
gsl_vector_set (&x.vector, x.vector.size - 1,
gsl_vector_get (abscissae, abscissae->size - 1));
/* Finally, initialize workspace knots using the now-known breakpoints */
s = gsl_bspline_knots (&x.vector, w);
free (storage);
}
/* Sum absolute errors in the resulting vs requested interior abscissae */
/* Provided as a fit quality metric which may be monitored by callers */
if (!s && abserr)
{
size_t i;
*abserr = 0;
for (i = 1; i < abscissae->size - 1; ++i)
*abserr += fabs ( gsl_bspline_greville_abscissa (i, w)
- gsl_vector_get (abscissae, i) );
}
return s;
}
static PyObject*
PyGSL_multimin_set_fdf(PyGSL_solver *self, PyObject *pyargs, PyObject *kw)
{
PyObject * f = NULL, * df = NULL, * fdf = NULL, * args = Py_None,
* x = NULL;
PyArrayObject * xa = NULL;
int n=0, flag=GSL_EFAILED;
PyGSL_array_index_t stride_recalc=-1;
double step=0.01, tol=1e-4;
gsl_vector_view gsl_x;
gsl_multimin_function_fdf * c_sys;
static const char *kwlist[] = {"f", "df", "fdf", "x0", "args", "step", "tol", NULL};
FUNC_MESS_BEGIN();
assert(PyGSL_solver_check(self));
if (self->solver == NULL) {
pygsl_error("Got a NULL Pointer of min.fdf", filename, __LINE__ - 3, GSL_EFAULT);
return NULL;
}
/* arguments PyFunction, Parameters, start Vector, step Vector */
if (0==PyArg_ParseTupleAndKeywords(pyargs, kw, "OOOO|Odd", (char **)kwlist,
&f, &df, &fdf, &x, &args, &step, &tol))
return NULL;
n=self->problem_dimensions[0];
xa = PyGSL_vector_check(x, n, PyGSL_DARRAY_INPUT(4), &stride_recalc, NULL);
if (xa == NULL){
PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);
goto fail;
}
gsl_x = gsl_vector_view_array_with_stride((double *)(xa->data), stride_recalc, xa->dimensions[0]);
if (self->c_sys != NULL) {
/* free the previous function and args */
c_sys = self->c_sys;
} else {
/* allocate function space */
c_sys=malloc(sizeof(gsl_multimin_function_fdf));
if (c_sys==NULL) {
pygsl_error("Could not allocate the object for the minimizer function",
filename, __LINE__ - 3, GSL_ENOMEM);
goto fail;
}
}
if(PyGSL_solver_func_set(self, args, f, df, fdf) != GSL_SUCCESS)
goto fail;
/* initialize the function struct */
c_sys->n=n;
c_sys->f =PyGSL_multimin_function_f;
c_sys->df =PyGSL_multimin_function_df;
c_sys->fdf=PyGSL_multimin_function_fdf;
c_sys->params=(void*)self;
if((flag = setjmp(self->buffer)) == 0){
self->isset = 1;
flag = gsl_multimin_fdfminimizer_set(self->solver, c_sys, &gsl_x.vector, step, tol);
if(PyGSL_ERROR_FLAG(flag) != GSL_SUCCESS){
goto fail;
}
}else{
goto fail;
}
self->c_sys = c_sys;
self->isset = 0;
Py_DECREF(xa);
self->set_called = 1;
Py_INCREF(Py_None);
FUNC_MESS_END();
return Py_None;
fail:
PyGSL_ERROR_FLAG(flag);
self->isset = 0;
Py_XDECREF(xa);
return NULL;
}
static PyObject*
PyGSL_multimin_set_f(PyGSL_solver *self, PyObject *pyargs, PyObject *kw)
{
PyObject* func = NULL, * args = Py_None, * x = NULL, * steps = NULL;
PyArrayObject * xa = NULL, * stepsa = NULL;
int n=0, flag=GSL_EFAILED;
PyGSL_array_index_t stride_recalc;
gsl_vector_view gsl_x;
gsl_vector_view gsl_steps;
gsl_multimin_function * c_sys = NULL;
static const char *kwlist[] = {"f", "x0", "args", "steps", NULL};
FUNC_MESS_BEGIN();
assert(PyGSL_solver_check(self));
if (self->solver == NULL) {
pygsl_error("Got a NULL Pointer of min.f", filename, __LINE__ - 3, GSL_EFAULT);
return NULL;
}
assert(pyargs);
/* arguments PyFunction, Parameters, start Vector, step Vector */
if (0==PyArg_ParseTupleAndKeywords(pyargs,kw,"OOOO", (char **)kwlist, &func,
&x,&args,&steps))
return NULL;
if(!PyCallable_Check(func)){
pygsl_error("First argument must be callable", filename, __LINE__ - 3, GSL_EBADFUNC);
return NULL;
}
n=self->problem_dimensions[0];
xa = PyGSL_vector_check(x, n, PyGSL_DARRAY_INPUT(4), &stride_recalc, NULL);
if (xa == NULL){
PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);
goto fail;
}
gsl_x = gsl_vector_view_array_with_stride((double *)(xa->data), stride_recalc, xa->dimensions[0]);
stepsa = PyGSL_vector_check(steps, n, PyGSL_DARRAY_INPUT(5), &stride_recalc, NULL);
if (stepsa == NULL){
PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);
goto fail;
}
gsl_steps = gsl_vector_view_array_with_stride((double *)(stepsa->data), stride_recalc, stepsa->dimensions[0]);
if (self->c_sys != NULL) {
/* free the previous function and args */
c_sys = self->c_sys;
} else {
/* allocate function space */
c_sys=calloc(1, sizeof(gsl_multimin_function));
if (c_sys == NULL) {
pygsl_error("Could not allocate the object for the minimizer function",
filename, __LINE__ - 3, GSL_ENOMEM);
goto fail;
}
}
DEBUG_MESS(3, "Everything allocated args = %p", args);
/* add new function and parameters */
if(PyGSL_solver_func_set(self, args, func, NULL, NULL) != GSL_SUCCESS)
goto fail;
/* initialize the function struct */
c_sys->n=n;
c_sys->f=PyGSL_multimin_function_f;
c_sys->params=(void*)self;
DEBUG_MESS(3, "Setting jmp buffer isset = % d", self->isset);
if((flag = setjmp(self->buffer)) == 0){
self->isset = 1;
flag = gsl_multimin_fminimizer_set(self->solver,c_sys, &gsl_x.vector, &gsl_steps.vector);
if(PyGSL_ERROR_FLAG(flag) != GSL_SUCCESS){
goto fail;
}
} else {
goto fail;
}
DEBUG_MESS(4, "Set evaluated. flag = %d", flag);
self->c_sys = c_sys;
Py_DECREF(xa);
Py_DECREF(stepsa);
self->set_called = 1;
Py_INCREF(Py_None);
self->isset = 0;
FUNC_MESS_END();
return Py_None;
fail:
FUNC_MESS("Fail");
PyGSL_ERROR_FLAG(flag);
self->isset = 0;
Py_XDECREF(xa);
Py_XDECREF(stepsa);
return NULL;
}
