Index: /issm/oecreview/Archive/14064-14311/Date.tex =================================================================== --- /issm/oecreview/Archive/14064-14311/Date.tex (revision 14312) +++ /issm/oecreview/Archive/14064-14311/Date.tex (revision 14312) @@ -0,0 +1,1 @@ +Feb-4-2013 Index: /issm/oecreview/Archive/14064-14311/ISSM-14068-14069.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14068-14069.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14068-14069.diff (revision 14312) @@ -0,0 +1,14 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a (revision 14068) ++++ ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a (revision 14069) + +Property changes on: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +___________________________________________________________________ +Added: svn:mime-type +## -0,0 +1 ## ++application/octet-stream Index: /issm/oecreview/Archive/14064-14311/ISSM-14069-14070.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14069-14070.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14069-14070.diff (revision 14312) @@ -0,0 +1,14 @@ +Index: ../trunk-jpl/src/c/Container/Observations.cpp +=================================================================== +--- ../trunk-jpl/src/c/Container/Observations.cpp (revision 14069) ++++ ../trunk-jpl/src/c/Container/Observations.cpp (revision 14070) +@@ -45,6 +45,9 @@ + IssmPDouble offset,minlength,minspacing,mintrimming,maxtrimming; + Observation *observation = NULL; + ++ /*Check that observations is not empty*/ ++ if(n==0) _error_("No observation found"); ++ + /*Get extrema*/ + xmin=x[0]; ymin=y[0]; + xmax=x[0]; ymax=y[0]; Index: /issm/oecreview/Archive/14064-14311/ISSM-14073-14074.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14073-14074.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14073-14074.diff (revision 14312) @@ -0,0 +1,45 @@ +Index: ../trunk-jpl/src/android/ISSM_Visual/res/layout/activity_issmvisual.xml +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/res/layout/activity_issmvisual.xml (revision 14073) ++++ ../trunk-jpl/src/android/ISSM_Visual/res/layout/activity_issmvisual.xml (revision 14074) +@@ -14,13 +14,13 @@ + android:layout_marginBottom="41dp" /> + + ++ android:layout_marginBottom="15dp" ++ android:text="alpha value = 0" /> + + ++ android:layout_marginBottom="12dp" > + + +- ++ android:layout_above="@+id/seekBar" ++ android:layout_alignParentRight="true" ++ android:text="Reset" /> + + Index: /issm/oecreview/Archive/14064-14311/ISSM-14077-14078.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14077-14078.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14077-14078.diff (revision 14312) @@ -0,0 +1,27720 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk (revision 14077) ++++ ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk (revision 14078) +@@ -4,3 +4,4 @@ + LOCAL_SRC_FILES := libISSMCore.a + LOCAL_EXPORT_C_INCLUDES := $(ISSM_DIR) + include $(PREBUILT_STATIC_LIBRARY) ++ +Index: ../trunk-jpl/src/android/ISSM/jni/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Android.mk (revision 14077) ++++ ../trunk-jpl/src/android/ISSM/jni/Android.mk (revision 14078) +@@ -11,9 +11,8 @@ + LOCAL_PATH := $(my_LOCAL_PATH) + LOCAL_ALLOW_UNDEFINED_SYMBOLS := true + LOCAL_CFLAGS := -Wno-psabi -DHAVE_CONFIG_H +-LOCAL_LDLIBS := -llog -ldl ++LOCAL_LDLIBS := -llog -ldl -lm + LOCAL_MODULE := IssmJni + LOCAL_SRC_FILES := Main.cpp +-LOCAL_STATIC_LIBRARIES := libISSMCore +- ++LOCAL_STATIC_LIBRARIES := libISSMCore libgsl libgslcblas + include $(BUILD_SHARED_LIBRARY) +Index: ../trunk-jpl/src/android/ISSM/jni/Application.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Application.mk (revision 14077) ++++ ../trunk-jpl/src/android/ISSM/jni/Application.mk (revision 14078) +@@ -1,3 +1,4 @@ +-APP_STL:=stlport_static ++APP_STL:= gnustl_static + APP_CPPFLAGS := -frtti + APP_CPPFLAGS += -fexceptions ++APP_ABI := armeabi +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgslcblas.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgslcblas.a +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgslcblas.a (revision 14077) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgslcblas.a (revision 14078) + +Property changes on: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgslcblas.a +___________________________________________________________________ +Added: svn:mime-type +## -0,0 +1 ## ++application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_UCHAR_H__ ++#define __GSL_MATRIX_UCHAR_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ unsigned char * data; ++ gsl_block_uchar * block; ++ int owner; ++} gsl_matrix_uchar; ++ ++typedef struct ++{ ++ gsl_matrix_uchar matrix; ++} _gsl_matrix_uchar_view; ++ ++typedef _gsl_matrix_uchar_view gsl_matrix_uchar_view; ++ ++typedef struct ++{ ++ gsl_matrix_uchar matrix; ++} _gsl_matrix_uchar_const_view; ++ ++typedef const _gsl_matrix_uchar_const_view gsl_matrix_uchar_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_uchar * ++gsl_matrix_uchar_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_uchar * ++gsl_matrix_uchar_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_uchar * ++gsl_matrix_uchar_alloc_from_block (gsl_block_uchar * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_uchar * ++gsl_matrix_uchar_alloc_from_matrix (gsl_matrix_uchar * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_uchar * ++gsl_vector_uchar_alloc_row_from_matrix (gsl_matrix_uchar * m, ++ const size_t i); ++ ++gsl_vector_uchar * ++gsl_vector_uchar_alloc_col_from_matrix (gsl_matrix_uchar * m, ++ const size_t j); ++ ++void gsl_matrix_uchar_free (gsl_matrix_uchar * m); ++ ++/* Views */ ++ ++_gsl_matrix_uchar_view ++gsl_matrix_uchar_submatrix (gsl_matrix_uchar * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_row (gsl_matrix_uchar * m, const size_t i); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_column (gsl_matrix_uchar * m, const size_t j); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_diagonal (gsl_matrix_uchar * m); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_subdiagonal (gsl_matrix_uchar * m, const size_t k); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_superdiagonal (gsl_matrix_uchar * m, const size_t k); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_subrow (gsl_matrix_uchar * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_uchar_view ++gsl_matrix_uchar_subcolumn (gsl_matrix_uchar * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_uchar_view ++gsl_matrix_uchar_view_array (unsigned char * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uchar_view ++gsl_matrix_uchar_view_array_with_tda (unsigned char * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_uchar_view ++gsl_matrix_uchar_view_vector (gsl_vector_uchar * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uchar_view ++gsl_matrix_uchar_view_vector_with_tda (gsl_vector_uchar * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_uchar_const_view ++gsl_matrix_uchar_const_submatrix (const gsl_matrix_uchar * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_row (const gsl_matrix_uchar * m, ++ const size_t i); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_column (const gsl_matrix_uchar * m, ++ const size_t j); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_diagonal (const gsl_matrix_uchar * m); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_subdiagonal (const gsl_matrix_uchar * m, ++ const size_t k); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_superdiagonal (const gsl_matrix_uchar * m, ++ const size_t k); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_subrow (const gsl_matrix_uchar * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_uchar_const_view ++gsl_matrix_uchar_const_subcolumn (const gsl_matrix_uchar * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_uchar_const_view ++gsl_matrix_uchar_const_view_array (const unsigned char * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uchar_const_view ++gsl_matrix_uchar_const_view_array_with_tda (const unsigned char * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_uchar_const_view ++gsl_matrix_uchar_const_view_vector (const gsl_vector_uchar * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uchar_const_view ++gsl_matrix_uchar_const_view_vector_with_tda (const gsl_vector_uchar * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_uchar_set_zero (gsl_matrix_uchar * m); ++void gsl_matrix_uchar_set_identity (gsl_matrix_uchar * m); ++void gsl_matrix_uchar_set_all (gsl_matrix_uchar * m, unsigned char x); ++ ++int gsl_matrix_uchar_fread (FILE * stream, gsl_matrix_uchar * m) ; ++int gsl_matrix_uchar_fwrite (FILE * stream, const gsl_matrix_uchar * m) ; ++int gsl_matrix_uchar_fscanf (FILE * stream, gsl_matrix_uchar * m); ++int gsl_matrix_uchar_fprintf (FILE * stream, const gsl_matrix_uchar * m, const char * format); ++ ++int gsl_matrix_uchar_memcpy(gsl_matrix_uchar * dest, const gsl_matrix_uchar * src); ++int gsl_matrix_uchar_swap(gsl_matrix_uchar * m1, gsl_matrix_uchar * m2); ++ ++int gsl_matrix_uchar_swap_rows(gsl_matrix_uchar * m, const size_t i, const size_t j); ++int gsl_matrix_uchar_swap_columns(gsl_matrix_uchar * m, const size_t i, const size_t j); ++int gsl_matrix_uchar_swap_rowcol(gsl_matrix_uchar * m, const size_t i, const size_t j); ++int gsl_matrix_uchar_transpose (gsl_matrix_uchar * m); ++int gsl_matrix_uchar_transpose_memcpy (gsl_matrix_uchar * dest, const gsl_matrix_uchar * src); ++ ++unsigned char gsl_matrix_uchar_max (const gsl_matrix_uchar * m); ++unsigned char gsl_matrix_uchar_min (const gsl_matrix_uchar * m); ++void gsl_matrix_uchar_minmax (const gsl_matrix_uchar * m, unsigned char * min_out, unsigned char * max_out); ++ ++void gsl_matrix_uchar_max_index (const gsl_matrix_uchar * m, size_t * imax, size_t *jmax); ++void gsl_matrix_uchar_min_index (const gsl_matrix_uchar * m, size_t * imin, size_t *jmin); ++void gsl_matrix_uchar_minmax_index (const gsl_matrix_uchar * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_uchar_equal (const gsl_matrix_uchar * a, const gsl_matrix_uchar * b); ++ ++int gsl_matrix_uchar_isnull (const gsl_matrix_uchar * m); ++int gsl_matrix_uchar_ispos (const gsl_matrix_uchar * m); ++int gsl_matrix_uchar_isneg (const gsl_matrix_uchar * m); ++int gsl_matrix_uchar_isnonneg (const gsl_matrix_uchar * m); ++ ++int gsl_matrix_uchar_add (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); ++int gsl_matrix_uchar_sub (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); ++int gsl_matrix_uchar_mul_elements (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); ++int gsl_matrix_uchar_div_elements (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); ++int gsl_matrix_uchar_scale (gsl_matrix_uchar * a, const double x); ++int gsl_matrix_uchar_add_constant (gsl_matrix_uchar * a, const double x); ++int gsl_matrix_uchar_add_diagonal (gsl_matrix_uchar * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_uchar_get_row(gsl_vector_uchar * v, const gsl_matrix_uchar * m, const size_t i); ++int gsl_matrix_uchar_get_col(gsl_vector_uchar * v, const gsl_matrix_uchar * m, const size_t j); ++int gsl_matrix_uchar_set_row(gsl_matrix_uchar * m, const size_t i, const gsl_vector_uchar * v); ++int gsl_matrix_uchar_set_col(gsl_matrix_uchar * m, const size_t j, const gsl_vector_uchar * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL unsigned char gsl_matrix_uchar_get(const gsl_matrix_uchar * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_uchar_set(gsl_matrix_uchar * m, const size_t i, const size_t j, const unsigned char x); ++INLINE_DECL unsigned char * gsl_matrix_uchar_ptr(gsl_matrix_uchar * m, const size_t i, const size_t j); ++INLINE_DECL const unsigned char * gsl_matrix_uchar_const_ptr(const gsl_matrix_uchar * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++unsigned char ++gsl_matrix_uchar_get(const gsl_matrix_uchar * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_uchar_set(gsl_matrix_uchar * m, const size_t i, const size_t j, const unsigned char x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++unsigned char * ++gsl_matrix_uchar_ptr(gsl_matrix_uchar * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (unsigned char *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const unsigned char * ++gsl_matrix_uchar_const_ptr(const gsl_matrix_uchar * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const unsigned char *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_FLOAT_H__ ++#define __GSL_PERMUTE_VECTOR_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_float (const gsl_permutation * p, gsl_vector_float * v); ++int gsl_permute_vector_float_inverse (const gsl_permutation * p, gsl_vector_float * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_complex_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ ++#define __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_complex_long_double_struct ++{ ++ size_t size; ++ long double *data; ++}; ++ ++typedef struct gsl_block_complex_long_double_struct gsl_block_complex_long_double; ++ ++gsl_block_complex_long_double *gsl_block_complex_long_double_alloc (const size_t n); ++gsl_block_complex_long_double *gsl_block_complex_long_double_calloc (const size_t n); ++void gsl_block_complex_long_double_free (gsl_block_complex_long_double * b); ++ ++int gsl_block_complex_long_double_fread (FILE * stream, gsl_block_complex_long_double * b); ++int gsl_block_complex_long_double_fwrite (FILE * stream, const gsl_block_complex_long_double * b); ++int gsl_block_complex_long_double_fscanf (FILE * stream, gsl_block_complex_long_double * b); ++int gsl_block_complex_long_double_fprintf (FILE * stream, const gsl_block_complex_long_double * b, const char *format); ++ ++int gsl_block_complex_long_double_raw_fread (FILE * stream, long double * b, const size_t n, const size_t stride); ++int gsl_block_complex_long_double_raw_fwrite (FILE * stream, const long double * b, const size_t n, const size_t stride); ++int gsl_block_complex_long_double_raw_fscanf (FILE * stream, long double * b, const size_t n, const size_t stride); ++int gsl_block_complex_long_double_raw_fprintf (FILE * stream, const long double * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_complex_long_double_size (const gsl_block_complex_long_double * b); ++long double * gsl_block_complex_long_double_data (const gsl_block_complex_long_double * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_INT_H__ ++#define __GSL_PERMUTE_INT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_int (const size_t * p, int * data, const size_t stride, const size_t n); ++int gsl_permute_int_inverse (const size_t * p, int * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h (revision 14078) +@@ -0,0 +1,139 @@ ++/* specfunc/gsl_sf_airy.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_AIRY_H__ ++#define __GSL_SF_AIRY_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Airy function Ai(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_airy_Ai_e(const double x, const gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Ai(const double x, gsl_mode_t mode); ++ ++ ++/* Airy function Bi(x) ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_airy_Bi_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Bi(const double x, gsl_mode_t mode); ++ ++ ++/* scaled Ai(x): ++ * Ai(x) x < 0 ++ * exp(+2/3 x^{3/2}) Ai(x) x > 0 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_airy_Ai_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Ai_scaled(const double x, gsl_mode_t mode); ++ ++ ++/* scaled Bi(x): ++ * Bi(x) x < 0 ++ * exp(-2/3 x^{3/2}) Bi(x) x > 0 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_airy_Bi_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Bi_scaled(const double x, gsl_mode_t mode); ++ ++ ++/* derivative Ai'(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_airy_Ai_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Ai_deriv(const double x, gsl_mode_t mode); ++ ++ ++/* derivative Bi'(x) ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_airy_Bi_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Bi_deriv(const double x, gsl_mode_t mode); ++ ++ ++/* scaled derivative Ai'(x): ++ * Ai'(x) x < 0 ++ * exp(+2/3 x^{3/2}) Ai'(x) x > 0 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_airy_Ai_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Ai_deriv_scaled(const double x, gsl_mode_t mode); ++ ++ ++/* scaled derivative: ++ * Bi'(x) x < 0 ++ * exp(-2/3 x^{3/2}) Bi'(x) x > 0 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_airy_Bi_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_airy_Bi_deriv_scaled(const double x, gsl_mode_t mode); ++ ++ ++/* Zeros of Ai(x) ++ */ ++int gsl_sf_airy_zero_Ai_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_airy_zero_Ai(unsigned int s); ++ ++ ++/* Zeros of Bi(x) ++ */ ++int gsl_sf_airy_zero_Bi_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_airy_zero_Bi(unsigned int s); ++ ++ ++/* Zeros of Ai'(x) ++ */ ++int gsl_sf_airy_zero_Ai_deriv_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_airy_zero_Ai_deriv(unsigned int s); ++ ++ ++/* Zeros of Bi'(x) ++ */ ++int gsl_sf_airy_zero_Bi_deriv_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_airy_zero_Bi_deriv(unsigned int s); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_AIRY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h (revision 14078) +@@ -0,0 +1,73 @@ ++/* specfunc/gsl_sf_gegenbauer.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_GEGENBAUER_H__ ++#define __GSL_SF_GEGENBAUER_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Evaluate Gegenbauer polynomials ++ * using explicit representations. ++ * ++ * exceptions: none ++ */ ++int gsl_sf_gegenpoly_1_e(double lambda, double x, gsl_sf_result * result); ++int gsl_sf_gegenpoly_2_e(double lambda, double x, gsl_sf_result * result); ++int gsl_sf_gegenpoly_3_e(double lambda, double x, gsl_sf_result * result); ++double gsl_sf_gegenpoly_1(double lambda, double x); ++double gsl_sf_gegenpoly_2(double lambda, double x); ++double gsl_sf_gegenpoly_3(double lambda, double x); ++ ++ ++/* Evaluate Gegenbauer polynomials. ++ * ++ * lambda > -1/2, n >= 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gegenpoly_n_e(int n, double lambda, double x, gsl_sf_result * result); ++double gsl_sf_gegenpoly_n(int n, double lambda, double x); ++ ++ ++/* Calculate array of Gegenbauer polynomials ++ * for n = (0, 1, 2, ... nmax) ++ * ++ * lambda > -1/2, nmax >= 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gegenpoly_array(int nmax, double lambda, double x, double * result_array); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_GEGENBAUER_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_ULONG_H__ ++#define __GSL_BLOCK_ULONG_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_ulong_struct ++{ ++ size_t size; ++ unsigned long *data; ++}; ++ ++typedef struct gsl_block_ulong_struct gsl_block_ulong; ++ ++gsl_block_ulong *gsl_block_ulong_alloc (const size_t n); ++gsl_block_ulong *gsl_block_ulong_calloc (const size_t n); ++void gsl_block_ulong_free (gsl_block_ulong * b); ++ ++int gsl_block_ulong_fread (FILE * stream, gsl_block_ulong * b); ++int gsl_block_ulong_fwrite (FILE * stream, const gsl_block_ulong * b); ++int gsl_block_ulong_fscanf (FILE * stream, gsl_block_ulong * b); ++int gsl_block_ulong_fprintf (FILE * stream, const gsl_block_ulong * b, const char *format); ++ ++int gsl_block_ulong_raw_fread (FILE * stream, unsigned long * b, const size_t n, const size_t stride); ++int gsl_block_ulong_raw_fwrite (FILE * stream, const unsigned long * b, const size_t n, const size_t stride); ++int gsl_block_ulong_raw_fscanf (FILE * stream, unsigned long * b, const size_t n, const size_t stride); ++int gsl_block_ulong_raw_fprintf (FILE * stream, const unsigned long * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_ulong_size (const gsl_block_ulong * b); ++unsigned long * gsl_block_ulong_data (const gsl_block_ulong * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_UCHAR_H__ ++#define __GSL_PERMUTE_UCHAR_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_uchar (const size_t * p, unsigned char * data, const size_t stride, const size_t n); ++int gsl_permute_uchar_inverse (const size_t * p, unsigned char * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h (revision 14078) +@@ -0,0 +1,127 @@ ++/* roots/gsl_roots.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Reid Priedhorsky, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_ROOTS_H__ ++#define __GSL_ROOTS_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*set) (void *state, gsl_function * f, double * root, double x_lower, double x_upper); ++ int (*iterate) (void *state, gsl_function * f, double * root, double * x_lower, double * x_upper); ++ } ++gsl_root_fsolver_type; ++ ++typedef struct ++ { ++ const gsl_root_fsolver_type * type; ++ gsl_function * function ; ++ double root ; ++ double x_lower; ++ double x_upper; ++ void *state; ++ } ++gsl_root_fsolver; ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*set) (void *state, gsl_function_fdf * f, double * root); ++ int (*iterate) (void *state, gsl_function_fdf * f, double * root); ++ } ++gsl_root_fdfsolver_type; ++ ++typedef struct ++ { ++ const gsl_root_fdfsolver_type * type; ++ gsl_function_fdf * fdf ; ++ double root ; ++ void *state; ++ } ++gsl_root_fdfsolver; ++ ++gsl_root_fsolver * ++gsl_root_fsolver_alloc (const gsl_root_fsolver_type * T); ++void gsl_root_fsolver_free (gsl_root_fsolver * s); ++ ++int gsl_root_fsolver_set (gsl_root_fsolver * s, ++ gsl_function * f, ++ double x_lower, double x_upper); ++ ++int gsl_root_fsolver_iterate (gsl_root_fsolver * s); ++ ++const char * gsl_root_fsolver_name (const gsl_root_fsolver * s); ++double gsl_root_fsolver_root (const gsl_root_fsolver * s); ++double gsl_root_fsolver_x_lower (const gsl_root_fsolver * s); ++double gsl_root_fsolver_x_upper (const gsl_root_fsolver * s); ++ ++ ++gsl_root_fdfsolver * ++gsl_root_fdfsolver_alloc (const gsl_root_fdfsolver_type * T); ++ ++int ++gsl_root_fdfsolver_set (gsl_root_fdfsolver * s, ++ gsl_function_fdf * fdf, double root); ++ ++int ++gsl_root_fdfsolver_iterate (gsl_root_fdfsolver * s); ++ ++void ++gsl_root_fdfsolver_free (gsl_root_fdfsolver * s); ++ ++const char * gsl_root_fdfsolver_name (const gsl_root_fdfsolver * s); ++double gsl_root_fdfsolver_root (const gsl_root_fdfsolver * s); ++ ++int ++gsl_root_test_interval (double x_lower, double x_upper, double epsabs, double epsrel); ++ ++int ++gsl_root_test_residual (double f, double epsabs); ++ ++int ++gsl_root_test_delta (double x1, double x0, double epsabs, double epsrel); ++ ++GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_bisection; ++GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_brent; ++GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_falsepos; ++GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_newton; ++GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_secant; ++GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_steffenson; ++ ++__END_DECLS ++ ++#endif /* __GSL_ROOTS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h (revision 14078) +@@ -0,0 +1,592 @@ ++/* linalg/gsl_linalg.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2006, 2007 Gerard Jungman, Brian Gough, Patrick Alken ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_LINALG_H__ ++#define __GSL_LINALG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++#define __BEGIN_DECLS extern "C" { ++#define __END_DECLS } ++#else ++#define __BEGIN_DECLS /* empty */ ++#define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef enum ++ { ++ GSL_LINALG_MOD_NONE = 0, ++ GSL_LINALG_MOD_TRANSPOSE = 1, ++ GSL_LINALG_MOD_CONJUGATE = 2 ++ } ++gsl_linalg_matrix_mod_t; ++ ++ ++/* Note: You can now use the gsl_blas_dgemm function instead of matmult */ ++ ++/* Simple implementation of matrix multiply. ++ * Calculates C = A.B ++ * ++ * exceptions: GSL_EBADLEN ++ */ ++int gsl_linalg_matmult (const gsl_matrix * A, ++ const gsl_matrix * B, ++ gsl_matrix * C); ++ ++ ++/* Simple implementation of matrix multiply. ++ * Allows transposition of either matrix, so it ++ * can compute A.B or Trans(A).B or A.Trans(B) or Trans(A).Trans(B) ++ * ++ * exceptions: GSL_EBADLEN ++ */ ++int gsl_linalg_matmult_mod (const gsl_matrix * A, ++ gsl_linalg_matrix_mod_t modA, ++ const gsl_matrix * B, ++ gsl_linalg_matrix_mod_t modB, ++ gsl_matrix * C); ++ ++/* Calculate the matrix exponential by the scaling and ++ * squaring method described in Moler + Van Loan, ++ * SIAM Rev 20, 801 (1978). The mode argument allows ++ * choosing an optimal strategy, from the table ++ * given in the paper, for a given precision. ++ * ++ * exceptions: GSL_ENOTSQR, GSL_EBADLEN ++ */ ++int gsl_linalg_exponential_ss( ++ const gsl_matrix * A, ++ gsl_matrix * eA, ++ gsl_mode_t mode ++ ); ++ ++ ++/* Householder Transformations */ ++ ++double gsl_linalg_householder_transform (gsl_vector * v); ++gsl_complex gsl_linalg_complex_householder_transform (gsl_vector_complex * v); ++ ++int gsl_linalg_householder_hm (double tau, ++ const gsl_vector * v, ++ gsl_matrix * A); ++ ++int gsl_linalg_householder_mh (double tau, ++ const gsl_vector * v, ++ gsl_matrix * A); ++ ++int gsl_linalg_householder_hv (double tau, ++ const gsl_vector * v, ++ gsl_vector * w); ++ ++int gsl_linalg_householder_hm1 (double tau, ++ gsl_matrix * A); ++ ++int gsl_linalg_complex_householder_hm (gsl_complex tau, ++ const gsl_vector_complex * v, ++ gsl_matrix_complex * A); ++ ++int gsl_linalg_complex_householder_mh (gsl_complex tau, ++ const gsl_vector_complex * v, ++ gsl_matrix_complex * A); ++ ++int gsl_linalg_complex_householder_hv (gsl_complex tau, ++ const gsl_vector_complex * v, ++ gsl_vector_complex * w); ++ ++/* Hessenberg reduction */ ++ ++int gsl_linalg_hessenberg_decomp(gsl_matrix *A, gsl_vector *tau); ++int gsl_linalg_hessenberg_unpack(gsl_matrix * H, gsl_vector * tau, ++ gsl_matrix * U); ++int gsl_linalg_hessenberg_unpack_accum(gsl_matrix * H, gsl_vector * tau, ++ gsl_matrix * U); ++int gsl_linalg_hessenberg_set_zero(gsl_matrix * H); ++int gsl_linalg_hessenberg_submatrix(gsl_matrix *M, gsl_matrix *A, ++ size_t top, gsl_vector *tau); ++ ++/* To support gsl-1.9 interface: DEPRECATED */ ++int gsl_linalg_hessenberg(gsl_matrix *A, gsl_vector *tau); ++ ++ ++/* Hessenberg-Triangular reduction */ ++ ++int gsl_linalg_hesstri_decomp(gsl_matrix * A, gsl_matrix * B, ++ gsl_matrix * U, gsl_matrix * V, ++ gsl_vector * work); ++ ++/* Singular Value Decomposition ++ ++ * exceptions: ++ */ ++ ++int ++gsl_linalg_SV_decomp (gsl_matrix * A, ++ gsl_matrix * V, ++ gsl_vector * S, ++ gsl_vector * work); ++ ++int ++gsl_linalg_SV_decomp_mod (gsl_matrix * A, ++ gsl_matrix * X, ++ gsl_matrix * V, ++ gsl_vector * S, ++ gsl_vector * work); ++ ++int gsl_linalg_SV_decomp_jacobi (gsl_matrix * A, ++ gsl_matrix * Q, ++ gsl_vector * S); ++ ++int ++gsl_linalg_SV_solve (const gsl_matrix * U, ++ const gsl_matrix * Q, ++ const gsl_vector * S, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++ ++/* LU Decomposition, Gaussian elimination with partial pivoting ++ */ ++ ++int gsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation * p, int *signum); ++ ++int gsl_linalg_LU_solve (const gsl_matrix * LU, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_LU_svx (const gsl_matrix * LU, ++ const gsl_permutation * p, ++ gsl_vector * x); ++ ++int gsl_linalg_LU_refine (const gsl_matrix * A, ++ const gsl_matrix * LU, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x, ++ gsl_vector * residual); ++ ++int gsl_linalg_LU_invert (const gsl_matrix * LU, ++ const gsl_permutation * p, ++ gsl_matrix * inverse); ++ ++double gsl_linalg_LU_det (gsl_matrix * LU, int signum); ++double gsl_linalg_LU_lndet (gsl_matrix * LU); ++int gsl_linalg_LU_sgndet (gsl_matrix * lu, int signum); ++ ++/* Complex LU Decomposition */ ++ ++int gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A, ++ gsl_permutation * p, ++ int *signum); ++ ++int gsl_linalg_complex_LU_solve (const gsl_matrix_complex * LU, ++ const gsl_permutation * p, ++ const gsl_vector_complex * b, ++ gsl_vector_complex * x); ++ ++int gsl_linalg_complex_LU_svx (const gsl_matrix_complex * LU, ++ const gsl_permutation * p, ++ gsl_vector_complex * x); ++ ++int gsl_linalg_complex_LU_refine (const gsl_matrix_complex * A, ++ const gsl_matrix_complex * LU, ++ const gsl_permutation * p, ++ const gsl_vector_complex * b, ++ gsl_vector_complex * x, ++ gsl_vector_complex * residual); ++ ++int gsl_linalg_complex_LU_invert (const gsl_matrix_complex * LU, ++ const gsl_permutation * p, ++ gsl_matrix_complex * inverse); ++ ++gsl_complex gsl_linalg_complex_LU_det (gsl_matrix_complex * LU, ++ int signum); ++ ++double gsl_linalg_complex_LU_lndet (gsl_matrix_complex * LU); ++ ++gsl_complex gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU, ++ int signum); ++ ++/* QR decomposition */ ++ ++int gsl_linalg_QR_decomp (gsl_matrix * A, ++ gsl_vector * tau); ++ ++int gsl_linalg_QR_solve (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_QR_svx (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ gsl_vector * x); ++ ++int gsl_linalg_QR_lssolve (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ const gsl_vector * b, ++ gsl_vector * x, ++ gsl_vector * residual); ++ ++ ++int gsl_linalg_QR_QRsolve (gsl_matrix * Q, ++ gsl_matrix * R, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_QR_Rsolve (const gsl_matrix * QR, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_QR_Rsvx (const gsl_matrix * QR, ++ gsl_vector * x); ++ ++int gsl_linalg_QR_update (gsl_matrix * Q, ++ gsl_matrix * R, ++ gsl_vector * w, ++ const gsl_vector * v); ++ ++int gsl_linalg_QR_QTvec (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ gsl_vector * v); ++ ++int gsl_linalg_QR_Qvec (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ gsl_vector * v); ++ ++int gsl_linalg_QR_QTmat (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ gsl_matrix * A); ++ ++int gsl_linalg_QR_unpack (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ gsl_matrix * Q, ++ gsl_matrix * R); ++ ++int gsl_linalg_R_solve (const gsl_matrix * R, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_R_svx (const gsl_matrix * R, ++ gsl_vector * x); ++ ++ ++/* Q R P^T decomposition */ ++ ++int gsl_linalg_QRPT_decomp (gsl_matrix * A, ++ gsl_vector * tau, ++ gsl_permutation * p, ++ int *signum, ++ gsl_vector * norm); ++ ++int gsl_linalg_QRPT_decomp2 (const gsl_matrix * A, ++ gsl_matrix * q, gsl_matrix * r, ++ gsl_vector * tau, ++ gsl_permutation * p, ++ int *signum, ++ gsl_vector * norm); ++ ++int gsl_linalg_QRPT_solve (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++ ++int gsl_linalg_QRPT_svx (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ const gsl_permutation * p, ++ gsl_vector * x); ++ ++int gsl_linalg_QRPT_QRsolve (const gsl_matrix * Q, ++ const gsl_matrix * R, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_QRPT_Rsolve (const gsl_matrix * QR, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_QRPT_Rsvx (const gsl_matrix * QR, ++ const gsl_permutation * p, ++ gsl_vector * x); ++ ++int gsl_linalg_QRPT_update (gsl_matrix * Q, ++ gsl_matrix * R, ++ const gsl_permutation * p, ++ gsl_vector * u, ++ const gsl_vector * v); ++ ++/* LQ decomposition */ ++ ++int gsl_linalg_LQ_decomp (gsl_matrix * A, gsl_vector * tau); ++ ++int gsl_linalg_LQ_solve_T (const gsl_matrix * LQ, const gsl_vector * tau, ++ const gsl_vector * b, gsl_vector * x); ++ ++int gsl_linalg_LQ_svx_T (const gsl_matrix * LQ, const gsl_vector * tau, ++ gsl_vector * x); ++ ++int gsl_linalg_LQ_lssolve_T (const gsl_matrix * LQ, const gsl_vector * tau, ++ const gsl_vector * b, gsl_vector * x, ++ gsl_vector * residual); ++ ++int gsl_linalg_LQ_Lsolve_T (const gsl_matrix * LQ, const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_LQ_Lsvx_T (const gsl_matrix * LQ, gsl_vector * x); ++ ++int gsl_linalg_L_solve_T (const gsl_matrix * L, const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_LQ_vecQ (const gsl_matrix * LQ, const gsl_vector * tau, ++ gsl_vector * v); ++ ++int gsl_linalg_LQ_vecQT (const gsl_matrix * LQ, const gsl_vector * tau, ++ gsl_vector * v); ++ ++int gsl_linalg_LQ_unpack (const gsl_matrix * LQ, const gsl_vector * tau, ++ gsl_matrix * Q, gsl_matrix * L); ++ ++int gsl_linalg_LQ_update (gsl_matrix * Q, gsl_matrix * R, ++ const gsl_vector * v, gsl_vector * w); ++int gsl_linalg_LQ_LQsolve (gsl_matrix * Q, gsl_matrix * L, ++ const gsl_vector * b, gsl_vector * x); ++ ++/* P^T L Q decomposition */ ++ ++int gsl_linalg_PTLQ_decomp (gsl_matrix * A, gsl_vector * tau, ++ gsl_permutation * p, int *signum, ++ gsl_vector * norm); ++ ++int gsl_linalg_PTLQ_decomp2 (const gsl_matrix * A, gsl_matrix * q, ++ gsl_matrix * r, gsl_vector * tau, ++ gsl_permutation * p, int *signum, ++ gsl_vector * norm); ++ ++int gsl_linalg_PTLQ_solve_T (const gsl_matrix * QR, ++ const gsl_vector * tau, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_PTLQ_svx_T (const gsl_matrix * LQ, ++ const gsl_vector * tau, ++ const gsl_permutation * p, ++ gsl_vector * x); ++ ++int gsl_linalg_PTLQ_LQsolve_T (const gsl_matrix * Q, const gsl_matrix * L, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_PTLQ_Lsolve_T (const gsl_matrix * LQ, ++ const gsl_permutation * p, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_PTLQ_Lsvx_T (const gsl_matrix * LQ, ++ const gsl_permutation * p, ++ gsl_vector * x); ++ ++int gsl_linalg_PTLQ_update (gsl_matrix * Q, gsl_matrix * L, ++ const gsl_permutation * p, ++ const gsl_vector * v, gsl_vector * w); ++ ++/* Cholesky Decomposition */ ++ ++int gsl_linalg_cholesky_decomp (gsl_matrix * A); ++ ++int gsl_linalg_cholesky_solve (const gsl_matrix * cholesky, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++int gsl_linalg_cholesky_svx (const gsl_matrix * cholesky, ++ gsl_vector * x); ++ ++int gsl_linalg_cholesky_invert(gsl_matrix * cholesky); ++ ++/* Cholesky decomposition with unit-diagonal triangular parts. ++ * A = L D L^T, where diag(L) = (1,1,...,1). ++ * Upon exit, A contains L and L^T as for Cholesky, and ++ * the diagonal of A is (1,1,...,1). The vector Dis set ++ * to the diagonal elements of the diagonal matrix D. ++ */ ++int gsl_linalg_cholesky_decomp_unit(gsl_matrix * A, gsl_vector * D); ++ ++/* Complex Cholesky Decomposition */ ++ ++int gsl_linalg_complex_cholesky_decomp (gsl_matrix_complex * A); ++ ++int gsl_linalg_complex_cholesky_solve (const gsl_matrix_complex * cholesky, ++ const gsl_vector_complex * b, ++ gsl_vector_complex * x); ++ ++int gsl_linalg_complex_cholesky_svx (const gsl_matrix_complex * cholesky, ++ gsl_vector_complex * x); ++ ++int gsl_linalg_complex_cholesky_invert(gsl_matrix_complex * cholesky); ++ ++ ++/* Symmetric to symmetric tridiagonal decomposition */ ++ ++int gsl_linalg_symmtd_decomp (gsl_matrix * A, ++ gsl_vector * tau); ++ ++int gsl_linalg_symmtd_unpack (const gsl_matrix * A, ++ const gsl_vector * tau, ++ gsl_matrix * Q, ++ gsl_vector * diag, ++ gsl_vector * subdiag); ++ ++int gsl_linalg_symmtd_unpack_T (const gsl_matrix * A, ++ gsl_vector * diag, ++ gsl_vector * subdiag); ++ ++/* Hermitian to symmetric tridiagonal decomposition */ ++ ++int gsl_linalg_hermtd_decomp (gsl_matrix_complex * A, ++ gsl_vector_complex * tau); ++ ++int gsl_linalg_hermtd_unpack (const gsl_matrix_complex * A, ++ const gsl_vector_complex * tau, ++ gsl_matrix_complex * U, ++ gsl_vector * diag, ++ gsl_vector * sudiag); ++ ++int gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex * A, ++ gsl_vector * diag, ++ gsl_vector * subdiag); ++ ++/* Linear Solve Using Householder Transformations ++ ++ * exceptions: ++ */ ++ ++int gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector * b, gsl_vector * x); ++int gsl_linalg_HH_svx (gsl_matrix * A, gsl_vector * x); ++ ++/* Linear solve for a symmetric tridiagonal system. ++ ++ * The input vectors represent the NxN matrix as follows: ++ * ++ * diag[0] offdiag[0] 0 ... ++ * offdiag[0] diag[1] offdiag[1] ... ++ * 0 offdiag[1] diag[2] ... ++ * 0 0 offdiag[2] ... ++ * ... ... ... ... ++ */ ++int gsl_linalg_solve_symm_tridiag (const gsl_vector * diag, ++ const gsl_vector * offdiag, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++/* Linear solve for a nonsymmetric tridiagonal system. ++ ++ * The input vectors represent the NxN matrix as follows: ++ * ++ * diag[0] abovediag[0] 0 ... ++ * belowdiag[0] diag[1] abovediag[1] ... ++ * 0 belowdiag[1] diag[2] ... ++ * 0 0 belowdiag[2] ... ++ * ... ... ... ... ++ */ ++int gsl_linalg_solve_tridiag (const gsl_vector * diag, ++ const gsl_vector * abovediag, ++ const gsl_vector * belowdiag, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++ ++/* Linear solve for a symmetric cyclic tridiagonal system. ++ ++ * The input vectors represent the NxN matrix as follows: ++ * ++ * diag[0] offdiag[0] 0 ..... offdiag[N-1] ++ * offdiag[0] diag[1] offdiag[1] ..... ++ * 0 offdiag[1] diag[2] ..... ++ * 0 0 offdiag[2] ..... ++ * ... ... ++ * offdiag[N-1] ... ++ */ ++int gsl_linalg_solve_symm_cyc_tridiag (const gsl_vector * diag, ++ const gsl_vector * offdiag, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++/* Linear solve for a nonsymmetric cyclic tridiagonal system. ++ ++ * The input vectors represent the NxN matrix as follows: ++ * ++ * diag[0] abovediag[0] 0 ..... belowdiag[N-1] ++ * belowdiag[0] diag[1] abovediag[1] ..... ++ * 0 belowdiag[1] diag[2] ++ * 0 0 belowdiag[2] ..... ++ * ... ... ++ * abovediag[N-1] ... ++ */ ++int gsl_linalg_solve_cyc_tridiag (const gsl_vector * diag, ++ const gsl_vector * abovediag, ++ const gsl_vector * belowdiag, ++ const gsl_vector * b, ++ gsl_vector * x); ++ ++ ++/* Bidiagonal decomposition */ ++ ++int gsl_linalg_bidiag_decomp (gsl_matrix * A, ++ gsl_vector * tau_U, ++ gsl_vector * tau_V); ++ ++int gsl_linalg_bidiag_unpack (const gsl_matrix * A, ++ const gsl_vector * tau_U, ++ gsl_matrix * U, ++ const gsl_vector * tau_V, ++ gsl_matrix * V, ++ gsl_vector * diag, ++ gsl_vector * superdiag); ++ ++int gsl_linalg_bidiag_unpack2 (gsl_matrix * A, ++ gsl_vector * tau_U, ++ gsl_vector * tau_V, ++ gsl_matrix * V); ++ ++int gsl_linalg_bidiag_unpack_B (const gsl_matrix * A, ++ gsl_vector * diag, ++ gsl_vector * superdiag); ++ ++/* Balancing */ ++ ++int gsl_linalg_balance_matrix (gsl_matrix * A, gsl_vector * D); ++int gsl_linalg_balance_accum (gsl_matrix * A, gsl_vector * D); ++int gsl_linalg_balance_columns (gsl_matrix * A, gsl_vector * D); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_LINALG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h (revision 14078) +@@ -0,0 +1,100 @@ ++/* permutation/gsl_permutation.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTATION_H__ ++#define __GSL_PERMUTATION_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_permutation_struct ++{ ++ size_t size; ++ size_t *data; ++}; ++ ++typedef struct gsl_permutation_struct gsl_permutation; ++ ++gsl_permutation *gsl_permutation_alloc (const size_t n); ++gsl_permutation *gsl_permutation_calloc (const size_t n); ++void gsl_permutation_init (gsl_permutation * p); ++void gsl_permutation_free (gsl_permutation * p); ++int gsl_permutation_memcpy (gsl_permutation * dest, const gsl_permutation * src); ++ ++int gsl_permutation_fread (FILE * stream, gsl_permutation * p); ++int gsl_permutation_fwrite (FILE * stream, const gsl_permutation * p); ++int gsl_permutation_fscanf (FILE * stream, gsl_permutation * p); ++int gsl_permutation_fprintf (FILE * stream, const gsl_permutation * p, const char *format); ++ ++size_t gsl_permutation_size (const gsl_permutation * p); ++size_t * gsl_permutation_data (const gsl_permutation * p); ++ ++int gsl_permutation_swap (gsl_permutation * p, const size_t i, const size_t j); ++ ++int gsl_permutation_valid (const gsl_permutation * p); ++void gsl_permutation_reverse (gsl_permutation * p); ++int gsl_permutation_inverse (gsl_permutation * inv, const gsl_permutation * p); ++int gsl_permutation_next (gsl_permutation * p); ++int gsl_permutation_prev (gsl_permutation * p); ++int gsl_permutation_mul (gsl_permutation * p, const gsl_permutation * pa, const gsl_permutation * pb); ++ ++int gsl_permutation_linear_to_canonical (gsl_permutation * q, const gsl_permutation * p); ++int gsl_permutation_canonical_to_linear (gsl_permutation * p, const gsl_permutation * q); ++ ++size_t gsl_permutation_inversions (const gsl_permutation * p); ++size_t gsl_permutation_linear_cycles (const gsl_permutation * p); ++size_t gsl_permutation_canonical_cycles (const gsl_permutation * q); ++ ++INLINE_DECL size_t gsl_permutation_get (const gsl_permutation * p, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++size_t ++gsl_permutation_get (const gsl_permutation * p, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= p->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return p->data[i]; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h (revision 14078) +@@ -0,0 +1,125 @@ ++/* monte/gsl_monte_vegas.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth ++ * Copyright (C) 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* header for the gsl "vegas" routines. Mike Booth, May 1998 */ ++ ++#ifndef __GSL_MONTE_VEGAS_H__ ++#define __GSL_MONTE_VEGAS_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++enum {GSL_VEGAS_MODE_IMPORTANCE = 1, ++ GSL_VEGAS_MODE_IMPORTANCE_ONLY = 0, ++ GSL_VEGAS_MODE_STRATIFIED = -1}; ++ ++typedef struct { ++ /* grid */ ++ size_t dim; ++ size_t bins_max; ++ unsigned int bins; ++ unsigned int boxes; /* these are both counted along the axes */ ++ double * xi; ++ double * xin; ++ double * delx; ++ double * weight; ++ double vol; ++ ++ double * x; ++ int * bin; ++ int * box; ++ ++ /* distribution */ ++ double * d; ++ ++ /* control variables */ ++ double alpha; ++ int mode; ++ int verbose; ++ unsigned int iterations; ++ int stage; ++ ++ /* scratch variables preserved between calls to vegas1/2/3 */ ++ double jac; ++ double wtd_int_sum; ++ double sum_wgts; ++ double chi_sum; ++ double chisq; ++ ++ double result; ++ double sigma; ++ ++ unsigned int it_start; ++ unsigned int it_num; ++ unsigned int samples; ++ unsigned int calls_per_box; ++ ++ FILE * ostream; ++ ++} gsl_monte_vegas_state; ++ ++int gsl_monte_vegas_integrate(gsl_monte_function * f, ++ double xl[], double xu[], ++ size_t dim, size_t calls, ++ gsl_rng * r, ++ gsl_monte_vegas_state *state, ++ double* result, double* abserr); ++ ++gsl_monte_vegas_state* gsl_monte_vegas_alloc(size_t dim); ++ ++int gsl_monte_vegas_init(gsl_monte_vegas_state* state); ++ ++void gsl_monte_vegas_free (gsl_monte_vegas_state* state); ++ ++double gsl_monte_vegas_chisq (const gsl_monte_vegas_state* state); ++void gsl_monte_vegas_runval (const gsl_monte_vegas_state* state, double * result, double * sigma); ++ ++typedef struct { ++ double alpha; ++ size_t iterations; ++ int stage; ++ int mode; ++ int verbose; ++ FILE * ostream; ++} gsl_monte_vegas_params; ++ ++void gsl_monte_vegas_params_get (const gsl_monte_vegas_state * state, ++ gsl_monte_vegas_params * params); ++ ++void gsl_monte_vegas_params_set (gsl_monte_vegas_state * state, ++ const gsl_monte_vegas_params * params); ++ ++__END_DECLS ++ ++#endif /* __GSL_MONTE_VEGAS_H__ */ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_USHORT_H__ ++#define __GSL_MATRIX_USHORT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ unsigned short * data; ++ gsl_block_ushort * block; ++ int owner; ++} gsl_matrix_ushort; ++ ++typedef struct ++{ ++ gsl_matrix_ushort matrix; ++} _gsl_matrix_ushort_view; ++ ++typedef _gsl_matrix_ushort_view gsl_matrix_ushort_view; ++ ++typedef struct ++{ ++ gsl_matrix_ushort matrix; ++} _gsl_matrix_ushort_const_view; ++ ++typedef const _gsl_matrix_ushort_const_view gsl_matrix_ushort_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_ushort * ++gsl_matrix_ushort_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_ushort * ++gsl_matrix_ushort_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_ushort * ++gsl_matrix_ushort_alloc_from_block (gsl_block_ushort * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_ushort * ++gsl_matrix_ushort_alloc_from_matrix (gsl_matrix_ushort * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_ushort * ++gsl_vector_ushort_alloc_row_from_matrix (gsl_matrix_ushort * m, ++ const size_t i); ++ ++gsl_vector_ushort * ++gsl_vector_ushort_alloc_col_from_matrix (gsl_matrix_ushort * m, ++ const size_t j); ++ ++void gsl_matrix_ushort_free (gsl_matrix_ushort * m); ++ ++/* Views */ ++ ++_gsl_matrix_ushort_view ++gsl_matrix_ushort_submatrix (gsl_matrix_ushort * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_row (gsl_matrix_ushort * m, const size_t i); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_column (gsl_matrix_ushort * m, const size_t j); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_diagonal (gsl_matrix_ushort * m); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_subdiagonal (gsl_matrix_ushort * m, const size_t k); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_superdiagonal (gsl_matrix_ushort * m, const size_t k); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_subrow (gsl_matrix_ushort * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_ushort_view ++gsl_matrix_ushort_subcolumn (gsl_matrix_ushort * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_ushort_view ++gsl_matrix_ushort_view_array (unsigned short * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ushort_view ++gsl_matrix_ushort_view_array_with_tda (unsigned short * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_ushort_view ++gsl_matrix_ushort_view_vector (gsl_vector_ushort * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ushort_view ++gsl_matrix_ushort_view_vector_with_tda (gsl_vector_ushort * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_ushort_const_view ++gsl_matrix_ushort_const_submatrix (const gsl_matrix_ushort * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_row (const gsl_matrix_ushort * m, ++ const size_t i); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_column (const gsl_matrix_ushort * m, ++ const size_t j); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_diagonal (const gsl_matrix_ushort * m); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_subdiagonal (const gsl_matrix_ushort * m, ++ const size_t k); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_superdiagonal (const gsl_matrix_ushort * m, ++ const size_t k); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_subrow (const gsl_matrix_ushort * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_ushort_const_view ++gsl_matrix_ushort_const_subcolumn (const gsl_matrix_ushort * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_ushort_const_view ++gsl_matrix_ushort_const_view_array (const unsigned short * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ushort_const_view ++gsl_matrix_ushort_const_view_array_with_tda (const unsigned short * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_ushort_const_view ++gsl_matrix_ushort_const_view_vector (const gsl_vector_ushort * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ushort_const_view ++gsl_matrix_ushort_const_view_vector_with_tda (const gsl_vector_ushort * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_ushort_set_zero (gsl_matrix_ushort * m); ++void gsl_matrix_ushort_set_identity (gsl_matrix_ushort * m); ++void gsl_matrix_ushort_set_all (gsl_matrix_ushort * m, unsigned short x); ++ ++int gsl_matrix_ushort_fread (FILE * stream, gsl_matrix_ushort * m) ; ++int gsl_matrix_ushort_fwrite (FILE * stream, const gsl_matrix_ushort * m) ; ++int gsl_matrix_ushort_fscanf (FILE * stream, gsl_matrix_ushort * m); ++int gsl_matrix_ushort_fprintf (FILE * stream, const gsl_matrix_ushort * m, const char * format); ++ ++int gsl_matrix_ushort_memcpy(gsl_matrix_ushort * dest, const gsl_matrix_ushort * src); ++int gsl_matrix_ushort_swap(gsl_matrix_ushort * m1, gsl_matrix_ushort * m2); ++ ++int gsl_matrix_ushort_swap_rows(gsl_matrix_ushort * m, const size_t i, const size_t j); ++int gsl_matrix_ushort_swap_columns(gsl_matrix_ushort * m, const size_t i, const size_t j); ++int gsl_matrix_ushort_swap_rowcol(gsl_matrix_ushort * m, const size_t i, const size_t j); ++int gsl_matrix_ushort_transpose (gsl_matrix_ushort * m); ++int gsl_matrix_ushort_transpose_memcpy (gsl_matrix_ushort * dest, const gsl_matrix_ushort * src); ++ ++unsigned short gsl_matrix_ushort_max (const gsl_matrix_ushort * m); ++unsigned short gsl_matrix_ushort_min (const gsl_matrix_ushort * m); ++void gsl_matrix_ushort_minmax (const gsl_matrix_ushort * m, unsigned short * min_out, unsigned short * max_out); ++ ++void gsl_matrix_ushort_max_index (const gsl_matrix_ushort * m, size_t * imax, size_t *jmax); ++void gsl_matrix_ushort_min_index (const gsl_matrix_ushort * m, size_t * imin, size_t *jmin); ++void gsl_matrix_ushort_minmax_index (const gsl_matrix_ushort * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_ushort_equal (const gsl_matrix_ushort * a, const gsl_matrix_ushort * b); ++ ++int gsl_matrix_ushort_isnull (const gsl_matrix_ushort * m); ++int gsl_matrix_ushort_ispos (const gsl_matrix_ushort * m); ++int gsl_matrix_ushort_isneg (const gsl_matrix_ushort * m); ++int gsl_matrix_ushort_isnonneg (const gsl_matrix_ushort * m); ++ ++int gsl_matrix_ushort_add (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); ++int gsl_matrix_ushort_sub (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); ++int gsl_matrix_ushort_mul_elements (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); ++int gsl_matrix_ushort_div_elements (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); ++int gsl_matrix_ushort_scale (gsl_matrix_ushort * a, const double x); ++int gsl_matrix_ushort_add_constant (gsl_matrix_ushort * a, const double x); ++int gsl_matrix_ushort_add_diagonal (gsl_matrix_ushort * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_ushort_get_row(gsl_vector_ushort * v, const gsl_matrix_ushort * m, const size_t i); ++int gsl_matrix_ushort_get_col(gsl_vector_ushort * v, const gsl_matrix_ushort * m, const size_t j); ++int gsl_matrix_ushort_set_row(gsl_matrix_ushort * m, const size_t i, const gsl_vector_ushort * v); ++int gsl_matrix_ushort_set_col(gsl_matrix_ushort * m, const size_t j, const gsl_vector_ushort * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL unsigned short gsl_matrix_ushort_get(const gsl_matrix_ushort * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_ushort_set(gsl_matrix_ushort * m, const size_t i, const size_t j, const unsigned short x); ++INLINE_DECL unsigned short * gsl_matrix_ushort_ptr(gsl_matrix_ushort * m, const size_t i, const size_t j); ++INLINE_DECL const unsigned short * gsl_matrix_ushort_const_ptr(const gsl_matrix_ushort * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++unsigned short ++gsl_matrix_ushort_get(const gsl_matrix_ushort * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_ushort_set(gsl_matrix_ushort * m, const size_t i, const size_t j, const unsigned short x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++unsigned short * ++gsl_matrix_ushort_ptr(gsl_matrix_ushort * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (unsigned short *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const unsigned short * ++gsl_matrix_ushort_const_ptr(const gsl_matrix_ushort * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const unsigned short *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_SHORT_H__ ++#define __GSL_STATISTICS_SHORT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_short_mean (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_variance (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_sd (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_variance_with_fixed_mean (const short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_short_sd_with_fixed_mean (const short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_short_tss (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_tss_m (const short data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_short_absdev (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_skew (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_kurtosis (const short data[], const size_t stride, const size_t n); ++double gsl_stats_short_lag1_autocorrelation (const short data[], const size_t stride, const size_t n); ++ ++double gsl_stats_short_covariance (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n); ++double gsl_stats_short_correlation (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_short_variance_m (const short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_short_sd_m (const short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_short_absdev_m (const short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_short_skew_m_sd (const short data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_short_kurtosis_m_sd (const short data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_short_lag1_autocorrelation_m (const short data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_short_covariance_m (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_short_pvariance (const short data1[], const size_t stride1, const size_t n1, const short data2[], const size_t stride2, const size_t n2); ++double gsl_stats_short_ttest (const short data1[], const size_t stride1, const size_t n1, const short data2[], const size_t stride2, const size_t n2); ++ ++short gsl_stats_short_max (const short data[], const size_t stride, const size_t n); ++short gsl_stats_short_min (const short data[], const size_t stride, const size_t n); ++void gsl_stats_short_minmax (short * min, short * max, const short data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_short_max_index (const short data[], const size_t stride, const size_t n); ++size_t gsl_stats_short_min_index (const short data[], const size_t stride, const size_t n); ++void gsl_stats_short_minmax_index (size_t * min_index, size_t * max_index, const short data[], const size_t stride, const size_t n); ++ ++double gsl_stats_short_median_from_sorted_data (const short sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_short_quantile_from_sorted_data (const short sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* gsl_nan.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_NAN_H__ ++#define __GSL_NAN_H__ ++ ++#ifdef INFINITY ++# define GSL_POSINF INFINITY ++# define GSL_NEGINF (-INFINITY) ++#elif defined(HUGE_VAL) ++# define GSL_POSINF HUGE_VAL ++# define GSL_NEGINF (-HUGE_VAL) ++#else ++# define GSL_POSINF (gsl_posinf()) ++# define GSL_NEGINF (gsl_neginf()) ++#endif ++ ++#ifdef NAN ++# define GSL_NAN NAN ++#elif defined(INFINITY) ++# define GSL_NAN (INFINITY/INFINITY) ++#else ++# define GSL_NAN (gsl_nan()) ++#endif ++ ++#define GSL_POSZERO (+0.0) ++#define GSL_NEGZERO (-0.0) ++ ++#endif /* __GSL_NAN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h (revision 14078) +@@ -0,0 +1,315 @@ ++/* specfunc/gsl_sf_legendre.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_LEGENDRE_H__ ++#define __GSL_SF_LEGENDRE_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* P_l(x) l >= 0; |x| <= 1 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Pl_e(const int l, const double x, gsl_sf_result * result); ++double gsl_sf_legendre_Pl(const int l, const double x); ++ ++ ++/* P_l(x) for l=0,...,lmax; |x| <= 1 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Pl_array( ++ const int lmax, const double x, ++ double * result_array ++ ); ++ ++ ++/* P_l(x) and P_l'(x) for l=0,...,lmax; |x| <= 1 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Pl_deriv_array( ++ const int lmax, const double x, ++ double * result_array, ++ double * result_deriv_array ++ ); ++ ++ ++/* P_l(x), l=1,2,3 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_legendre_P1_e(double x, gsl_sf_result * result); ++int gsl_sf_legendre_P2_e(double x, gsl_sf_result * result); ++int gsl_sf_legendre_P3_e(double x, gsl_sf_result * result); ++double gsl_sf_legendre_P1(const double x); ++double gsl_sf_legendre_P2(const double x); ++double gsl_sf_legendre_P3(const double x); ++ ++ ++/* Q_0(x), x > -1, x != 1 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Q0_e(const double x, gsl_sf_result * result); ++double gsl_sf_legendre_Q0(const double x); ++ ++ ++/* Q_1(x), x > -1, x != 1 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Q1_e(const double x, gsl_sf_result * result); ++double gsl_sf_legendre_Q1(const double x); ++ ++ ++/* Q_l(x), x > -1, x != 1, l >= 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_Ql_e(const int l, const double x, gsl_sf_result * result); ++double gsl_sf_legendre_Ql(const int l, const double x); ++ ++ ++/* P_l^m(x) m >= 0; l >= m; |x| <= 1.0 ++ * ++ * Note that this function grows combinatorially with l. ++ * Therefore we can easily generate an overflow for l larger ++ * than about 150. ++ * ++ * There is no trouble for small m, but when m and l are both large, ++ * then there will be trouble. Rather than allow overflows, these ++ * functions refuse to calculate when they can sense that l and m are ++ * too big. ++ * ++ * If you really want to calculate a spherical harmonic, then DO NOT ++ * use this. Instead use legendre_sphPlm() below, which uses a similar ++ * recursion, but with the normalized functions. ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_legendre_Plm_e(const int l, const int m, const double x, gsl_sf_result * result); ++double gsl_sf_legendre_Plm(const int l, const int m, const double x); ++ ++ ++/* P_l^m(x) m >= 0; l >= m; |x| <= 1.0 ++ * l=|m|,...,lmax ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_legendre_Plm_array( ++ const int lmax, const int m, const double x, ++ double * result_array ++ ); ++ ++ ++/* P_l^m(x) and d(P_l^m(x))/dx; m >= 0; lmax >= m; |x| <= 1.0 ++ * l=|m|,...,lmax ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_legendre_Plm_deriv_array( ++ const int lmax, const int m, const double x, ++ double * result_array, ++ double * result_deriv_array ++ ); ++ ++ ++/* P_l^m(x), normalized properly for use in spherical harmonics ++ * m >= 0; l >= m; |x| <= 1.0 ++ * ++ * There is no overflow problem, as there is for the ++ * standard normalization of P_l^m(x). ++ * ++ * Specifically, it returns: ++ * ++ * sqrt((2l+1)/(4pi)) sqrt((l-m)!/(l+m)!) P_l^m(x) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_sphPlm_e(const int l, int m, const double x, gsl_sf_result * result); ++double gsl_sf_legendre_sphPlm(const int l, const int m, const double x); ++ ++ ++/* sphPlm(l,m,x) values ++ * m >= 0; l >= m; |x| <= 1.0 ++ * l=|m|,...,lmax ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_sphPlm_array( ++ const int lmax, int m, const double x, ++ double * result_array ++ ); ++ ++ ++/* sphPlm(l,m,x) and d(sphPlm(l,m,x))/dx values ++ * m >= 0; l >= m; |x| <= 1.0 ++ * l=|m|,...,lmax ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_sphPlm_deriv_array( ++ const int lmax, const int m, const double x, ++ double * result_array, ++ double * result_deriv_array ++ ); ++ ++ ++ ++/* size of result_array[] needed for the array versions of Plm ++ * (lmax - m + 1) ++ */ ++int gsl_sf_legendre_array_size(const int lmax, const int m); ++ ++/* Irregular Spherical Conical Function ++ * P^{1/2}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_half_e(const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_half(const double lambda, const double x); ++ ++ ++/* Regular Spherical Conical Function ++ * P^{-1/2}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_mhalf_e(const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_mhalf(const double lambda, const double x); ++ ++ ++/* Conical Function ++ * P^{0}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_0_e(const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_0(const double lambda, const double x); ++ ++ ++/* Conical Function ++ * P^{1}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_1_e(const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_1(const double lambda, const double x); ++ ++ ++/* Regular Spherical Conical Function ++ * P^{-1/2-l}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0, l >= -1 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_sph_reg_e(const int l, const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_sph_reg(const int l, const double lambda, const double x); ++ ++ ++/* Regular Cylindrical Conical Function ++ * P^{-m}_{-1/2 + I lambda}(x) ++ * ++ * x > -1.0, m >= -1 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_conicalP_cyl_reg_e(const int m, const double lambda, const double x, gsl_sf_result * result); ++double gsl_sf_conicalP_cyl_reg(const int m, const double lambda, const double x); ++ ++ ++/* The following spherical functions are specializations ++ * of Legendre functions which give the regular eigenfunctions ++ * of the Laplacian on a 3-dimensional hyperbolic space. ++ * Of particular interest is the flat limit, which is ++ * Flat-Lim := {lambda->Inf, eta->0, lambda*eta fixed}. ++ */ ++ ++/* Zeroth radial eigenfunction of the Laplacian on the ++ * 3-dimensional hyperbolic space. ++ * ++ * legendre_H3d_0(lambda,eta) := sin(lambda*eta)/(lambda*sinh(eta)) ++ * ++ * Normalization: ++ * Flat-Lim legendre_H3d_0(lambda,eta) = j_0(lambda*eta) ++ * ++ * eta >= 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_H3d_0_e(const double lambda, const double eta, gsl_sf_result * result); ++double gsl_sf_legendre_H3d_0(const double lambda, const double eta); ++ ++ ++/* First radial eigenfunction of the Laplacian on the ++ * 3-dimensional hyperbolic space. ++ * ++ * legendre_H3d_1(lambda,eta) := ++ * 1/sqrt(lambda^2 + 1) sin(lam eta)/(lam sinh(eta)) ++ * (coth(eta) - lambda cot(lambda*eta)) ++ * ++ * Normalization: ++ * Flat-Lim legendre_H3d_1(lambda,eta) = j_1(lambda*eta) ++ * ++ * eta >= 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_H3d_1_e(const double lambda, const double eta, gsl_sf_result * result); ++double gsl_sf_legendre_H3d_1(const double lambda, const double eta); ++ ++ ++/* l'th radial eigenfunction of the Laplacian on the ++ * 3-dimensional hyperbolic space. ++ * ++ * Normalization: ++ * Flat-Lim legendre_H3d_l(l,lambda,eta) = j_l(lambda*eta) ++ * ++ * eta >= 0.0, l >= 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_legendre_H3d_e(const int l, const double lambda, const double eta, gsl_sf_result * result); ++double gsl_sf_legendre_H3d(const int l, const double lambda, const double eta); ++ ++ ++/* Array of H3d(ell), 0 <= ell <= lmax ++ */ ++int gsl_sf_legendre_H3d_array(const int lmax, const double lambda, const double eta, double * result_array); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_LEGENDRE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_INT_H__ ++#define __GSL_PERMUTE_VECTOR_INT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_int (const gsl_permutation * p, gsl_vector_int * v); ++int gsl_permute_vector_int_inverse (const gsl_permutation * p, gsl_vector_int * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h (revision 14078) +@@ -0,0 +1,251 @@ ++/* vector/gsl_vector_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_COMPLEX_FLOAT_H__ ++#define __GSL_VECTOR_COMPLEX_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ float *data; ++ gsl_block_complex_float *block; ++ int owner; ++} gsl_vector_complex_float; ++ ++typedef struct ++{ ++ gsl_vector_complex_float vector; ++} _gsl_vector_complex_float_view; ++ ++typedef _gsl_vector_complex_float_view gsl_vector_complex_float_view; ++ ++typedef struct ++{ ++ gsl_vector_complex_float vector; ++} _gsl_vector_complex_float_const_view; ++ ++typedef const _gsl_vector_complex_float_const_view gsl_vector_complex_float_const_view; ++ ++/* Allocation */ ++ ++gsl_vector_complex_float *gsl_vector_complex_float_alloc (const size_t n); ++gsl_vector_complex_float *gsl_vector_complex_float_calloc (const size_t n); ++ ++gsl_vector_complex_float * ++gsl_vector_complex_float_alloc_from_block (gsl_block_complex_float * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_complex_float * ++gsl_vector_complex_float_alloc_from_vector (gsl_vector_complex_float * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_complex_float_free (gsl_vector_complex_float * v); ++ ++/* Views */ ++ ++_gsl_vector_complex_float_view ++gsl_vector_complex_float_view_array (float *base, ++ size_t n); ++ ++_gsl_vector_complex_float_view ++gsl_vector_complex_float_view_array_with_stride (float *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_float_const_view ++gsl_vector_complex_float_const_view_array (const float *base, ++ size_t n); ++ ++_gsl_vector_complex_float_const_view ++gsl_vector_complex_float_const_view_array_with_stride (const float *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_float_view ++gsl_vector_complex_float_subvector (gsl_vector_complex_float *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_float_view ++gsl_vector_complex_float_subvector_with_stride (gsl_vector_complex_float *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_float_const_view ++gsl_vector_complex_float_const_subvector (const gsl_vector_complex_float *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_float_const_view ++gsl_vector_complex_float_const_subvector_with_stride (const gsl_vector_complex_float *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_float_view ++gsl_vector_complex_float_real (gsl_vector_complex_float *v); ++ ++_gsl_vector_float_view ++gsl_vector_complex_float_imag (gsl_vector_complex_float *v); ++ ++_gsl_vector_float_const_view ++gsl_vector_complex_float_const_real (const gsl_vector_complex_float *v); ++ ++_gsl_vector_float_const_view ++gsl_vector_complex_float_const_imag (const gsl_vector_complex_float *v); ++ ++ ++/* Operations */ ++ ++void gsl_vector_complex_float_set_zero (gsl_vector_complex_float * v); ++void gsl_vector_complex_float_set_all (gsl_vector_complex_float * v, ++ gsl_complex_float z); ++int gsl_vector_complex_float_set_basis (gsl_vector_complex_float * v, size_t i); ++ ++int gsl_vector_complex_float_fread (FILE * stream, ++ gsl_vector_complex_float * v); ++int gsl_vector_complex_float_fwrite (FILE * stream, ++ const gsl_vector_complex_float * v); ++int gsl_vector_complex_float_fscanf (FILE * stream, ++ gsl_vector_complex_float * v); ++int gsl_vector_complex_float_fprintf (FILE * stream, ++ const gsl_vector_complex_float * v, ++ const char *format); ++ ++int gsl_vector_complex_float_memcpy (gsl_vector_complex_float * dest, const gsl_vector_complex_float * src); ++ ++int gsl_vector_complex_float_reverse (gsl_vector_complex_float * v); ++ ++int gsl_vector_complex_float_swap (gsl_vector_complex_float * v, gsl_vector_complex_float * w); ++int gsl_vector_complex_float_swap_elements (gsl_vector_complex_float * v, const size_t i, const size_t j); ++ ++int gsl_vector_complex_float_equal (const gsl_vector_complex_float * u, ++ const gsl_vector_complex_float * v); ++ ++int gsl_vector_complex_float_isnull (const gsl_vector_complex_float * v); ++int gsl_vector_complex_float_ispos (const gsl_vector_complex_float * v); ++int gsl_vector_complex_float_isneg (const gsl_vector_complex_float * v); ++int gsl_vector_complex_float_isnonneg (const gsl_vector_complex_float * v); ++ ++int gsl_vector_complex_float_add (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); ++int gsl_vector_complex_float_sub (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); ++int gsl_vector_complex_float_mul (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); ++int gsl_vector_complex_float_div (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); ++int gsl_vector_complex_float_scale (gsl_vector_complex_float * a, const gsl_complex_float x); ++int gsl_vector_complex_float_add_constant (gsl_vector_complex_float * a, const gsl_complex_float x); ++ ++INLINE_DECL gsl_complex_float gsl_vector_complex_float_get (const gsl_vector_complex_float * v, const size_t i); ++INLINE_DECL void gsl_vector_complex_float_set (gsl_vector_complex_float * v, const size_t i, gsl_complex_float z); ++INLINE_DECL gsl_complex_float *gsl_vector_complex_float_ptr (gsl_vector_complex_float * v, const size_t i); ++INLINE_DECL const gsl_complex_float *gsl_vector_complex_float_const_ptr (const gsl_vector_complex_float * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex_float ++gsl_vector_complex_float_get (const gsl_vector_complex_float * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ gsl_complex_float zero = {{0, 0}}; ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); ++ } ++#endif ++ return *GSL_COMPLEX_FLOAT_AT (v, i); ++} ++ ++INLINE_FUN ++void ++gsl_vector_complex_float_set (gsl_vector_complex_float * v, ++ const size_t i, gsl_complex_float z) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ *GSL_COMPLEX_FLOAT_AT (v, i) = z; ++} ++ ++INLINE_FUN ++gsl_complex_float * ++gsl_vector_complex_float_ptr (gsl_vector_complex_float * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_FLOAT_AT (v, i); ++} ++ ++INLINE_FUN ++const gsl_complex_float * ++gsl_vector_complex_float_const_ptr (const gsl_vector_complex_float * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_FLOAT_AT (v, i); ++} ++ ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h (revision 14078) +@@ -0,0 +1,69 @@ ++/* specfunc/gsl_sf_lambert.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_LAMBERT_H__ ++#define __GSL_SF_LAMBERT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Lambert's Function W_0(x) ++ * ++ * W_0(x) is the principal branch of the ++ * implicit function defined by W e^W = x. ++ * ++ * -1/E < x < \infty ++ * ++ * exceptions: GSL_EMAXITER; ++ */ ++int gsl_sf_lambert_W0_e(double x, gsl_sf_result * result); ++double gsl_sf_lambert_W0(double x); ++ ++ ++/* Lambert's Function W_{-1}(x) ++ * ++ * W_{-1}(x) is the second real branch of the ++ * implicit function defined by W e^W = x. ++ * It agrees with W_0(x) when x >= 0. ++ * ++ * -1/E < x < \infty ++ * ++ * exceptions: GSL_MAXITER; ++ */ ++int gsl_sf_lambert_Wm1_e(double x, gsl_sf_result * result); ++double gsl_sf_lambert_Wm1(double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_LAMBERT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_CHAR_H__ ++#define __GSL_PERMUTE_CHAR_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_char (const size_t * p, char * data, const size_t stride, const size_t n); ++int gsl_permute_char_inverse (const size_t * p, char * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_FLOAT_H__ ++#define __GSL_BLOCK_FLOAT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_float_struct ++{ ++ size_t size; ++ float *data; ++}; ++ ++typedef struct gsl_block_float_struct gsl_block_float; ++ ++gsl_block_float *gsl_block_float_alloc (const size_t n); ++gsl_block_float *gsl_block_float_calloc (const size_t n); ++void gsl_block_float_free (gsl_block_float * b); ++ ++int gsl_block_float_fread (FILE * stream, gsl_block_float * b); ++int gsl_block_float_fwrite (FILE * stream, const gsl_block_float * b); ++int gsl_block_float_fscanf (FILE * stream, gsl_block_float * b); ++int gsl_block_float_fprintf (FILE * stream, const gsl_block_float * b, const char *format); ++ ++int gsl_block_float_raw_fread (FILE * stream, float * b, const size_t n, const size_t stride); ++int gsl_block_float_raw_fwrite (FILE * stream, const float * b, const size_t n, const size_t stride); ++int gsl_block_float_raw_fscanf (FILE * stream, float * b, const size_t n, const size_t stride); ++int gsl_block_float_raw_fprintf (FILE * stream, const float * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_float_size (const gsl_block_float * b); ++float * gsl_block_float_data (const gsl_block_float * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h (revision 14078) +@@ -0,0 +1,97 @@ ++/* monte/gsl_monte_miser.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth ++ * Copyright (C) 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: MJB */ ++ ++#ifndef __GSL_MONTE_MISER_H__ ++#define __GSL_MONTE_MISER_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ size_t min_calls; ++ size_t min_calls_per_bisection; ++ double dither; ++ double estimate_frac; ++ double alpha; ++ size_t dim; ++ int estimate_style; ++ int depth; ++ int verbose; ++ double * x; ++ double * xmid; ++ double * sigma_l; ++ double * sigma_r; ++ double * fmax_l; ++ double * fmax_r; ++ double * fmin_l; ++ double * fmin_r; ++ double * fsum_l; ++ double * fsum_r; ++ double * fsum2_l; ++ double * fsum2_r; ++ size_t * hits_l; ++ size_t * hits_r; ++} gsl_monte_miser_state; ++ ++int gsl_monte_miser_integrate(gsl_monte_function * f, ++ const double xl[], const double xh[], ++ size_t dim, size_t calls, ++ gsl_rng *r, ++ gsl_monte_miser_state* state, ++ double *result, double *abserr); ++ ++gsl_monte_miser_state* gsl_monte_miser_alloc(size_t dim); ++ ++int gsl_monte_miser_init(gsl_monte_miser_state* state); ++ ++void gsl_monte_miser_free(gsl_monte_miser_state* state); ++ ++typedef struct { ++ double estimate_frac; ++ size_t min_calls; ++ size_t min_calls_per_bisection; ++ double alpha; ++ double dither; ++} gsl_monte_miser_params; ++ ++void gsl_monte_miser_params_get (const gsl_monte_miser_state * state, ++ gsl_monte_miser_params * params); ++ ++void gsl_monte_miser_params_set (gsl_monte_miser_state * state, ++ const gsl_monte_miser_params * params); ++ ++__END_DECLS ++ ++#endif /* __GSL_MONTE_MISER_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_INT_H__ ++#define __GSL_SORT_VECTOR_INT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_int (gsl_vector_int * v); ++int gsl_sort_vector_int_index (gsl_permutation * p, const gsl_vector_int * v); ++ ++int gsl_sort_vector_int_smallest (int * dest, const size_t k, const gsl_vector_int * v); ++int gsl_sort_vector_int_largest (int * dest, const size_t k, const gsl_vector_int * v); ++ ++int gsl_sort_vector_int_smallest_index (size_t * p, const size_t k, const gsl_vector_int * v); ++int gsl_sort_vector_int_largest_index (size_t * p, const size_t k, const gsl_vector_int * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_SHORT_H__ ++#define __GSL_MATRIX_SHORT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ short * data; ++ gsl_block_short * block; ++ int owner; ++} gsl_matrix_short; ++ ++typedef struct ++{ ++ gsl_matrix_short matrix; ++} _gsl_matrix_short_view; ++ ++typedef _gsl_matrix_short_view gsl_matrix_short_view; ++ ++typedef struct ++{ ++ gsl_matrix_short matrix; ++} _gsl_matrix_short_const_view; ++ ++typedef const _gsl_matrix_short_const_view gsl_matrix_short_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_short * ++gsl_matrix_short_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_short * ++gsl_matrix_short_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_short * ++gsl_matrix_short_alloc_from_block (gsl_block_short * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_short * ++gsl_matrix_short_alloc_from_matrix (gsl_matrix_short * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_short * ++gsl_vector_short_alloc_row_from_matrix (gsl_matrix_short * m, ++ const size_t i); ++ ++gsl_vector_short * ++gsl_vector_short_alloc_col_from_matrix (gsl_matrix_short * m, ++ const size_t j); ++ ++void gsl_matrix_short_free (gsl_matrix_short * m); ++ ++/* Views */ ++ ++_gsl_matrix_short_view ++gsl_matrix_short_submatrix (gsl_matrix_short * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_short_view ++gsl_matrix_short_row (gsl_matrix_short * m, const size_t i); ++ ++_gsl_vector_short_view ++gsl_matrix_short_column (gsl_matrix_short * m, const size_t j); ++ ++_gsl_vector_short_view ++gsl_matrix_short_diagonal (gsl_matrix_short * m); ++ ++_gsl_vector_short_view ++gsl_matrix_short_subdiagonal (gsl_matrix_short * m, const size_t k); ++ ++_gsl_vector_short_view ++gsl_matrix_short_superdiagonal (gsl_matrix_short * m, const size_t k); ++ ++_gsl_vector_short_view ++gsl_matrix_short_subrow (gsl_matrix_short * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_short_view ++gsl_matrix_short_subcolumn (gsl_matrix_short * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_short_view ++gsl_matrix_short_view_array (short * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_short_view ++gsl_matrix_short_view_array_with_tda (short * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_short_view ++gsl_matrix_short_view_vector (gsl_vector_short * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_short_view ++gsl_matrix_short_view_vector_with_tda (gsl_vector_short * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_short_const_view ++gsl_matrix_short_const_submatrix (const gsl_matrix_short * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_row (const gsl_matrix_short * m, ++ const size_t i); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_column (const gsl_matrix_short * m, ++ const size_t j); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_diagonal (const gsl_matrix_short * m); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_subdiagonal (const gsl_matrix_short * m, ++ const size_t k); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_superdiagonal (const gsl_matrix_short * m, ++ const size_t k); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_subrow (const gsl_matrix_short * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_short_const_view ++gsl_matrix_short_const_subcolumn (const gsl_matrix_short * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_short_const_view ++gsl_matrix_short_const_view_array (const short * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_short_const_view ++gsl_matrix_short_const_view_array_with_tda (const short * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_short_const_view ++gsl_matrix_short_const_view_vector (const gsl_vector_short * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_short_const_view ++gsl_matrix_short_const_view_vector_with_tda (const gsl_vector_short * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_short_set_zero (gsl_matrix_short * m); ++void gsl_matrix_short_set_identity (gsl_matrix_short * m); ++void gsl_matrix_short_set_all (gsl_matrix_short * m, short x); ++ ++int gsl_matrix_short_fread (FILE * stream, gsl_matrix_short * m) ; ++int gsl_matrix_short_fwrite (FILE * stream, const gsl_matrix_short * m) ; ++int gsl_matrix_short_fscanf (FILE * stream, gsl_matrix_short * m); ++int gsl_matrix_short_fprintf (FILE * stream, const gsl_matrix_short * m, const char * format); ++ ++int gsl_matrix_short_memcpy(gsl_matrix_short * dest, const gsl_matrix_short * src); ++int gsl_matrix_short_swap(gsl_matrix_short * m1, gsl_matrix_short * m2); ++ ++int gsl_matrix_short_swap_rows(gsl_matrix_short * m, const size_t i, const size_t j); ++int gsl_matrix_short_swap_columns(gsl_matrix_short * m, const size_t i, const size_t j); ++int gsl_matrix_short_swap_rowcol(gsl_matrix_short * m, const size_t i, const size_t j); ++int gsl_matrix_short_transpose (gsl_matrix_short * m); ++int gsl_matrix_short_transpose_memcpy (gsl_matrix_short * dest, const gsl_matrix_short * src); ++ ++short gsl_matrix_short_max (const gsl_matrix_short * m); ++short gsl_matrix_short_min (const gsl_matrix_short * m); ++void gsl_matrix_short_minmax (const gsl_matrix_short * m, short * min_out, short * max_out); ++ ++void gsl_matrix_short_max_index (const gsl_matrix_short * m, size_t * imax, size_t *jmax); ++void gsl_matrix_short_min_index (const gsl_matrix_short * m, size_t * imin, size_t *jmin); ++void gsl_matrix_short_minmax_index (const gsl_matrix_short * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_short_equal (const gsl_matrix_short * a, const gsl_matrix_short * b); ++ ++int gsl_matrix_short_isnull (const gsl_matrix_short * m); ++int gsl_matrix_short_ispos (const gsl_matrix_short * m); ++int gsl_matrix_short_isneg (const gsl_matrix_short * m); ++int gsl_matrix_short_isnonneg (const gsl_matrix_short * m); ++ ++int gsl_matrix_short_add (gsl_matrix_short * a, const gsl_matrix_short * b); ++int gsl_matrix_short_sub (gsl_matrix_short * a, const gsl_matrix_short * b); ++int gsl_matrix_short_mul_elements (gsl_matrix_short * a, const gsl_matrix_short * b); ++int gsl_matrix_short_div_elements (gsl_matrix_short * a, const gsl_matrix_short * b); ++int gsl_matrix_short_scale (gsl_matrix_short * a, const double x); ++int gsl_matrix_short_add_constant (gsl_matrix_short * a, const double x); ++int gsl_matrix_short_add_diagonal (gsl_matrix_short * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_short_get_row(gsl_vector_short * v, const gsl_matrix_short * m, const size_t i); ++int gsl_matrix_short_get_col(gsl_vector_short * v, const gsl_matrix_short * m, const size_t j); ++int gsl_matrix_short_set_row(gsl_matrix_short * m, const size_t i, const gsl_vector_short * v); ++int gsl_matrix_short_set_col(gsl_matrix_short * m, const size_t j, const gsl_vector_short * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL short gsl_matrix_short_get(const gsl_matrix_short * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_short_set(gsl_matrix_short * m, const size_t i, const size_t j, const short x); ++INLINE_DECL short * gsl_matrix_short_ptr(gsl_matrix_short * m, const size_t i, const size_t j); ++INLINE_DECL const short * gsl_matrix_short_const_ptr(const gsl_matrix_short * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++short ++gsl_matrix_short_get(const gsl_matrix_short * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_short_set(gsl_matrix_short * m, const size_t i, const size_t j, const short x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++short * ++gsl_matrix_short_ptr(gsl_matrix_short * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (short *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const short * ++gsl_matrix_short_const_ptr(const gsl_matrix_short * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const short *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_DOUBLE_H__ ++#define __GSL_BLOCK_DOUBLE_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_struct ++{ ++ size_t size; ++ double *data; ++}; ++ ++typedef struct gsl_block_struct gsl_block; ++ ++gsl_block *gsl_block_alloc (const size_t n); ++gsl_block *gsl_block_calloc (const size_t n); ++void gsl_block_free (gsl_block * b); ++ ++int gsl_block_fread (FILE * stream, gsl_block * b); ++int gsl_block_fwrite (FILE * stream, const gsl_block * b); ++int gsl_block_fscanf (FILE * stream, gsl_block * b); ++int gsl_block_fprintf (FILE * stream, const gsl_block * b, const char *format); ++ ++int gsl_block_raw_fread (FILE * stream, double * b, const size_t n, const size_t stride); ++int gsl_block_raw_fwrite (FILE * stream, const double * b, const size_t n, const size_t stride); ++int gsl_block_raw_fscanf (FILE * stream, double * b, const size_t n, const size_t stride); ++int gsl_block_raw_fprintf (FILE * stream, const double * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_size (const gsl_block * b); ++double * gsl_block_data (const gsl_block * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h (revision 14078) +@@ -0,0 +1,31 @@ ++/* const/gsl_const.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST__ ++#define __GSL_CONST__ ++ ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_CONST__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_UINT_H__ ++#define __GSL_STATISTICS_UINT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_uint_mean (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_variance (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_sd (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_variance_with_fixed_mean (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uint_sd_with_fixed_mean (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uint_tss (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_tss_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_uint_absdev (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_skew (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_kurtosis (const unsigned int data[], const size_t stride, const size_t n); ++double gsl_stats_uint_lag1_autocorrelation (const unsigned int data[], const size_t stride, const size_t n); ++ ++double gsl_stats_uint_covariance (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n); ++double gsl_stats_uint_correlation (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_uint_variance_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uint_sd_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uint_absdev_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uint_skew_m_sd (const unsigned int data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_uint_kurtosis_m_sd (const unsigned int data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_uint_lag1_autocorrelation_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_uint_covariance_m (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_uint_pvariance (const unsigned int data1[], const size_t stride1, const size_t n1, const unsigned int data2[], const size_t stride2, const size_t n2); ++double gsl_stats_uint_ttest (const unsigned int data1[], const size_t stride1, const size_t n1, const unsigned int data2[], const size_t stride2, const size_t n2); ++ ++unsigned int gsl_stats_uint_max (const unsigned int data[], const size_t stride, const size_t n); ++unsigned int gsl_stats_uint_min (const unsigned int data[], const size_t stride, const size_t n); ++void gsl_stats_uint_minmax (unsigned int * min, unsigned int * max, const unsigned int data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_uint_max_index (const unsigned int data[], const size_t stride, const size_t n); ++size_t gsl_stats_uint_min_index (const unsigned int data[], const size_t stride, const size_t n); ++void gsl_stats_uint_minmax_index (size_t * min_index, size_t * max_index, const unsigned int data[], const size_t stride, const size_t n); ++ ++double gsl_stats_uint_median_from_sorted_data (const unsigned int sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_uint_quantile_from_sorted_data (const unsigned int sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h (revision 14078) +@@ -0,0 +1,102 @@ ++/* gsl_minmax.h ++ * ++ * Copyright (C) 2008 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MINMAX_H__ ++#define __GSL_MINMAX_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Define MAX and MIN macros/functions if they don't exist. */ ++ ++/* plain old macros for general use */ ++#define GSL_MAX(a,b) ((a) > (b) ? (a) : (b)) ++#define GSL_MIN(a,b) ((a) < (b) ? (a) : (b)) ++ ++/* function versions of the above, in case they are needed */ ++double gsl_max (double a, double b); ++double gsl_min (double a, double b); ++ ++/* inline-friendly strongly typed versions */ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN int GSL_MAX_INT (int a, int b); ++INLINE_FUN int GSL_MIN_INT (int a, int b); ++INLINE_FUN double GSL_MAX_DBL (double a, double b); ++INLINE_FUN double GSL_MIN_DBL (double a, double b); ++INLINE_FUN long double GSL_MAX_LDBL (long double a, long double b); ++INLINE_FUN long double GSL_MIN_LDBL (long double a, long double b); ++ ++INLINE_FUN int ++GSL_MAX_INT (int a, int b) ++{ ++ return GSL_MAX (a, b); ++} ++ ++INLINE_FUN int ++GSL_MIN_INT (int a, int b) ++{ ++ return GSL_MIN (a, b); ++} ++ ++INLINE_FUN double ++GSL_MAX_DBL (double a, double b) ++{ ++ return GSL_MAX (a, b); ++} ++ ++INLINE_FUN double ++GSL_MIN_DBL (double a, double b) ++{ ++ return GSL_MIN (a, b); ++} ++ ++INLINE_FUN long double ++GSL_MAX_LDBL (long double a, long double b) ++{ ++ return GSL_MAX (a, b); ++} ++ ++INLINE_FUN long double ++GSL_MIN_LDBL (long double a, long double b) ++{ ++ return GSL_MIN (a, b); ++} ++#else ++#define GSL_MAX_INT(a,b) GSL_MAX(a,b) ++#define GSL_MIN_INT(a,b) GSL_MIN(a,b) ++#define GSL_MAX_DBL(a,b) GSL_MAX(a,b) ++#define GSL_MIN_DBL(a,b) GSL_MIN(a,b) ++#define GSL_MAX_LDBL(a,b) GSL_MAX(a,b) ++#define GSL_MIN_LDBL(a,b) GSL_MIN(a,b) ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_LONG_DOUBLE_H__ ++#define __GSL_PERMUTE_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_long_double (const size_t * p, long double * data, const size_t stride, const size_t n); ++int gsl_permute_long_double_inverse (const size_t * p, long double * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_UCHAR_H__ ++#define __GSL_SORT_VECTOR_UCHAR_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_uchar (gsl_vector_uchar * v); ++int gsl_sort_vector_uchar_index (gsl_permutation * p, const gsl_vector_uchar * v); ++ ++int gsl_sort_vector_uchar_smallest (unsigned char * dest, const size_t k, const gsl_vector_uchar * v); ++int gsl_sort_vector_uchar_largest (unsigned char * dest, const size_t k, const gsl_vector_uchar * v); ++ ++int gsl_sort_vector_uchar_smallest_index (size_t * p, const size_t k, const gsl_vector_uchar * v); ++int gsl_sort_vector_uchar_largest_index (size_t * p, const size_t k, const gsl_vector_uchar * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_DOUBLE_H__ ++#define __GSL_PERMUTE_VECTOR_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector (const gsl_permutation * p, gsl_vector * v); ++int gsl_permute_vector_inverse (const gsl_permutation * p, gsl_vector * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h (revision 14078) +@@ -0,0 +1,167 @@ ++/* specfunc/gsl_sf_expint.h ++ * ++ * Copyright (C) 2007 Brian Gough ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_EXPINT_H__ ++#define __GSL_SF_EXPINT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* E_1(x) := Re[ Integrate[ Exp[-xt]/t, {t,1,Infinity}] ] ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_E1_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_E1(const double x); ++ ++ ++/* E_2(x) := Re[ Integrate[ Exp[-xt]/t^2, {t,1,Infinity}] ] ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_E2_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_E2(const double x); ++ ++ ++/* E_n(x) := Re[ Integrate[ Exp[-xt]/t^n, {t,1,Infinity}] ] ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_En_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_expint_En(const int n, const double x); ++ ++ ++/* E_1_scaled(x) := exp(x) E_1(x) ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_E1_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_E1_scaled(const double x); ++ ++ ++/* E_2_scaled(x) := exp(x) E_2(x) ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_E2_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_E2_scaled(const double x); ++ ++/* E_n_scaled(x) := exp(x) E_n(x) ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_En_scaled_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_expint_En_scaled(const int n, const double x); ++ ++ ++/* Ei(x) := - PV Integrate[ Exp[-t]/t, {t,-x,Infinity}] ++ * := PV Integrate[ Exp[t]/t, {t,-Infinity,x}] ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_Ei_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_Ei(const double x); ++ ++ ++/* Ei_scaled(x) := exp(-x) Ei(x) ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_expint_Ei_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_Ei_scaled(const double x); ++ ++ ++/* Shi(x) := Integrate[ Sinh[t]/t, {t,0,x}] ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_Shi_e(const double x, gsl_sf_result * result); ++double gsl_sf_Shi(const double x); ++ ++ ++/* Chi(x) := Re[ M_EULER + log(x) + Integrate[(Cosh[t]-1)/t, {t,0,x}] ] ++ * ++ * x != 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_Chi_e(const double x, gsl_sf_result * result); ++double gsl_sf_Chi(const double x); ++ ++ ++/* Ei_3(x) := Integral[ Exp[-t^3], {t,0,x}] ++ * ++ * x >= 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_expint_3_e(const double x, gsl_sf_result * result); ++double gsl_sf_expint_3(double x); ++ ++ ++/* Si(x) := Integrate[ Sin[t]/t, {t,0,x}] ++ * ++ * exceptions: none ++ */ ++int gsl_sf_Si_e(const double x, gsl_sf_result * result); ++double gsl_sf_Si(const double x); ++ ++ ++/* Ci(x) := -Integrate[ Cos[t]/t, {t,x,Infinity}] ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_Ci_e(const double x, gsl_sf_result * result); ++double gsl_sf_Ci(const double x); ++ ++ ++/* AtanInt(x) := Integral[ Arctan[t]/t, {t,0,x}] ++ * ++ * ++ * exceptions: ++ */ ++int gsl_sf_atanint_e(const double x, gsl_sf_result * result); ++double gsl_sf_atanint(const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_EXPINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_SHORT_H__ ++#define __GSL_PERMUTE_SHORT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_short (const size_t * p, short * data, const size_t stride, const size_t n); ++int gsl_permute_short_inverse (const size_t * p, short * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h (revision 14078) +@@ -0,0 +1,86 @@ ++/* fft/gsl_fft_halfcomplex.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_HALFCOMPLEX_H__ ++#define __GSL_FFT_HALFCOMPLEX_H__ ++ ++#include ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_fft_halfcomplex_radix2_backward (double data[], const size_t stride, const size_t n); ++int gsl_fft_halfcomplex_radix2_inverse (double data[], const size_t stride, const size_t n); ++int gsl_fft_halfcomplex_radix2_transform (double data[], const size_t stride, const size_t n); ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex *twiddle[64]; ++ gsl_complex *trig; ++ } ++gsl_fft_halfcomplex_wavetable; ++ ++gsl_fft_halfcomplex_wavetable * gsl_fft_halfcomplex_wavetable_alloc (size_t n); ++ ++void ++gsl_fft_halfcomplex_wavetable_free (gsl_fft_halfcomplex_wavetable * wavetable); ++ ++ ++int gsl_fft_halfcomplex_backward (double data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable * wavetable, ++ gsl_fft_real_workspace * work); ++ ++int gsl_fft_halfcomplex_inverse (double data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable * wavetable, ++ gsl_fft_real_workspace * work); ++ ++int gsl_fft_halfcomplex_transform (double data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable * wavetable, ++ gsl_fft_real_workspace * work); ++ ++int ++gsl_fft_halfcomplex_unpack (const double halfcomplex_coefficient[], ++ double complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++int ++gsl_fft_halfcomplex_radix2_unpack (const double halfcomplex_coefficient[], ++ double complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_HALFCOMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_CHAR_H__ ++#define __GSL_SORT_VECTOR_CHAR_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_char (gsl_vector_char * v); ++int gsl_sort_vector_char_index (gsl_permutation * p, const gsl_vector_char * v); ++ ++int gsl_sort_vector_char_smallest (char * dest, const size_t k, const gsl_vector_char * v); ++int gsl_sort_vector_char_largest (char * dest, const size_t k, const gsl_vector_char * v); ++ ++int gsl_sort_vector_char_smallest_index (size_t * p, const size_t k, const gsl_vector_char * v); ++int gsl_sort_vector_char_largest_index (size_t * p, const size_t k, const gsl_vector_char * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h (revision 14078) +@@ -0,0 +1,103 @@ ++/* complex/gsl_complex.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_COMPLEX_H__ ++#define __GSL_COMPLEX_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* two consecutive built-in types as a complex number */ ++typedef double * gsl_complex_packed ; ++typedef float * gsl_complex_packed_float ; ++typedef long double * gsl_complex_packed_long_double ; ++ ++typedef const double * gsl_const_complex_packed ; ++typedef const float * gsl_const_complex_packed_float ; ++typedef const long double * gsl_const_complex_packed_long_double ; ++ ++ ++/* 2N consecutive built-in types as N complex numbers */ ++typedef double * gsl_complex_packed_array ; ++typedef float * gsl_complex_packed_array_float ; ++typedef long double * gsl_complex_packed_array_long_double ; ++ ++typedef const double * gsl_const_complex_packed_array ; ++typedef const float * gsl_const_complex_packed_array_float ; ++typedef const long double * gsl_const_complex_packed_array_long_double ; ++ ++ ++/* Yes... this seems weird. Trust us. The point is just that ++ sometimes you want to make it obvious that something is ++ an output value. The fact that it lacks a 'const' may not ++ be enough of a clue for people in some contexts. ++ */ ++typedef double * gsl_complex_packed_ptr ; ++typedef float * gsl_complex_packed_float_ptr ; ++typedef long double * gsl_complex_packed_long_double_ptr ; ++ ++typedef const double * gsl_const_complex_packed_ptr ; ++typedef const float * gsl_const_complex_packed_float_ptr ; ++typedef const long double * gsl_const_complex_packed_long_double_ptr ; ++ ++ ++typedef struct ++ { ++ long double dat[2]; ++ } ++gsl_complex_long_double; ++ ++typedef struct ++ { ++ double dat[2]; ++ } ++gsl_complex; ++ ++typedef struct ++ { ++ float dat[2]; ++ } ++gsl_complex_float; ++ ++#define GSL_REAL(z) ((z).dat[0]) ++#define GSL_IMAG(z) ((z).dat[1]) ++#define GSL_COMPLEX_P(zp) ((zp)->dat) ++#define GSL_COMPLEX_P_REAL(zp) ((zp)->dat[0]) ++#define GSL_COMPLEX_P_IMAG(zp) ((zp)->dat[1]) ++#define GSL_COMPLEX_EQ(z1,z2) (((z1).dat[0] == (z2).dat[0]) && ((z1).dat[1] == (z2).dat[1])) ++ ++#define GSL_SET_COMPLEX(zp,x,y) do {(zp)->dat[0]=(x); (zp)->dat[1]=(y);} while(0) ++#define GSL_SET_REAL(zp,x) do {(zp)->dat[0]=(x);} while(0) ++#define GSL_SET_IMAG(zp,y) do {(zp)->dat[1]=(y);} while(0) ++ ++#define GSL_SET_COMPLEX_PACKED(zp,n,x,y) do {*((zp)+2*(n))=(x); *((zp)+(2*(n)+1))=(y);} while(0) ++ ++__END_DECLS ++ ++#endif /* __GSL_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h (revision 14078) +@@ -0,0 +1,82 @@ ++/* specfunc/gsl_sf_log.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_LOG_H__ ++#define __GSL_SF_LOG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Provide a logarithm function with GSL semantics. ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_log_e(const double x, gsl_sf_result * result); ++double gsl_sf_log(const double x); ++ ++ ++/* Log(|x|) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_log_abs_e(const double x, gsl_sf_result * result); ++double gsl_sf_log_abs(const double x); ++ ++ ++/* Complex Logarithm ++ * exp(lnr + I theta) = zr + I zi ++ * Returns argument in [-pi,pi]. ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_complex_log_e(const double zr, const double zi, gsl_sf_result * lnr, gsl_sf_result * theta); ++ ++ ++/* Log(1 + x) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_log_1plusx_e(const double x, gsl_sf_result * result); ++double gsl_sf_log_1plusx(const double x); ++ ++ ++/* Log(1 + x) - x ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_log_1plusx_mx_e(const double x, gsl_sf_result * result); ++double gsl_sf_log_1plusx_mx(const double x); ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_LOG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_LONG_H__ ++#define __GSL_STATISTICS_LONG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_long_mean (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_variance (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_sd (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_variance_with_fixed_mean (const long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_sd_with_fixed_mean (const long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_tss (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_tss_m (const long data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_long_absdev (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_skew (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_kurtosis (const long data[], const size_t stride, const size_t n); ++double gsl_stats_long_lag1_autocorrelation (const long data[], const size_t stride, const size_t n); ++ ++double gsl_stats_long_covariance (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n); ++double gsl_stats_long_correlation (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_long_variance_m (const long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_sd_m (const long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_absdev_m (const long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_skew_m_sd (const long data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_long_kurtosis_m_sd (const long data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_long_lag1_autocorrelation_m (const long data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_long_covariance_m (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_long_pvariance (const long data1[], const size_t stride1, const size_t n1, const long data2[], const size_t stride2, const size_t n2); ++double gsl_stats_long_ttest (const long data1[], const size_t stride1, const size_t n1, const long data2[], const size_t stride2, const size_t n2); ++ ++long gsl_stats_long_max (const long data[], const size_t stride, const size_t n); ++long gsl_stats_long_min (const long data[], const size_t stride, const size_t n); ++void gsl_stats_long_minmax (long * min, long * max, const long data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_long_max_index (const long data[], const size_t stride, const size_t n); ++size_t gsl_stats_long_min_index (const long data[], const size_t stride, const size_t n); ++void gsl_stats_long_minmax_index (size_t * min_index, size_t * max_index, const long data[], const size_t stride, const size_t n); ++ ++double gsl_stats_long_median_from_sorted_data (const long sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_long_quantile_from_sorted_data (const long sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_complex_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_COMPLEX_DOUBLE_H__ ++#define __GSL_BLOCK_COMPLEX_DOUBLE_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_complex_struct ++{ ++ size_t size; ++ double *data; ++}; ++ ++typedef struct gsl_block_complex_struct gsl_block_complex; ++ ++gsl_block_complex *gsl_block_complex_alloc (const size_t n); ++gsl_block_complex *gsl_block_complex_calloc (const size_t n); ++void gsl_block_complex_free (gsl_block_complex * b); ++ ++int gsl_block_complex_fread (FILE * stream, gsl_block_complex * b); ++int gsl_block_complex_fwrite (FILE * stream, const gsl_block_complex * b); ++int gsl_block_complex_fscanf (FILE * stream, gsl_block_complex * b); ++int gsl_block_complex_fprintf (FILE * stream, const gsl_block_complex * b, const char *format); ++ ++int gsl_block_complex_raw_fread (FILE * stream, double * b, const size_t n, const size_t stride); ++int gsl_block_complex_raw_fwrite (FILE * stream, const double * b, const size_t n, const size_t stride); ++int gsl_block_complex_raw_fscanf (FILE * stream, double * b, const size_t n, const size_t stride); ++int gsl_block_complex_raw_fprintf (FILE * stream, const double * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_complex_size (const gsl_block_complex * b); ++double * gsl_block_complex_data (const gsl_block_complex * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ ++#define __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_long_double (const gsl_permutation * p, gsl_vector_long_double * v); ++int gsl_permute_vector_long_double_inverse (const gsl_permutation * p, gsl_vector_long_double * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_INT_H__ ++#define __GSL_VECTOR_INT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ int *data; ++ gsl_block_int *block; ++ int owner; ++} ++gsl_vector_int; ++ ++typedef struct ++{ ++ gsl_vector_int vector; ++} _gsl_vector_int_view; ++ ++typedef _gsl_vector_int_view gsl_vector_int_view; ++ ++typedef struct ++{ ++ gsl_vector_int vector; ++} _gsl_vector_int_const_view; ++ ++typedef const _gsl_vector_int_const_view gsl_vector_int_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_int *gsl_vector_int_alloc (const size_t n); ++gsl_vector_int *gsl_vector_int_calloc (const size_t n); ++ ++gsl_vector_int *gsl_vector_int_alloc_from_block (gsl_block_int * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_int *gsl_vector_int_alloc_from_vector (gsl_vector_int * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_int_free (gsl_vector_int * v); ++ ++/* Views */ ++ ++_gsl_vector_int_view ++gsl_vector_int_view_array (int *v, size_t n); ++ ++_gsl_vector_int_view ++gsl_vector_int_view_array_with_stride (int *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_int_const_view ++gsl_vector_int_const_view_array (const int *v, size_t n); ++ ++_gsl_vector_int_const_view ++gsl_vector_int_const_view_array_with_stride (const int *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_int_view ++gsl_vector_int_subvector (gsl_vector_int *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_int_view ++gsl_vector_int_subvector_with_stride (gsl_vector_int *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_int_const_view ++gsl_vector_int_const_subvector (const gsl_vector_int *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_int_const_view ++gsl_vector_int_const_subvector_with_stride (const gsl_vector_int *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_int_set_zero (gsl_vector_int * v); ++void gsl_vector_int_set_all (gsl_vector_int * v, int x); ++int gsl_vector_int_set_basis (gsl_vector_int * v, size_t i); ++ ++int gsl_vector_int_fread (FILE * stream, gsl_vector_int * v); ++int gsl_vector_int_fwrite (FILE * stream, const gsl_vector_int * v); ++int gsl_vector_int_fscanf (FILE * stream, gsl_vector_int * v); ++int gsl_vector_int_fprintf (FILE * stream, const gsl_vector_int * v, ++ const char *format); ++ ++int gsl_vector_int_memcpy (gsl_vector_int * dest, const gsl_vector_int * src); ++ ++int gsl_vector_int_reverse (gsl_vector_int * v); ++ ++int gsl_vector_int_swap (gsl_vector_int * v, gsl_vector_int * w); ++int gsl_vector_int_swap_elements (gsl_vector_int * v, const size_t i, const size_t j); ++ ++int gsl_vector_int_max (const gsl_vector_int * v); ++int gsl_vector_int_min (const gsl_vector_int * v); ++void gsl_vector_int_minmax (const gsl_vector_int * v, int * min_out, int * max_out); ++ ++size_t gsl_vector_int_max_index (const gsl_vector_int * v); ++size_t gsl_vector_int_min_index (const gsl_vector_int * v); ++void gsl_vector_int_minmax_index (const gsl_vector_int * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_int_add (gsl_vector_int * a, const gsl_vector_int * b); ++int gsl_vector_int_sub (gsl_vector_int * a, const gsl_vector_int * b); ++int gsl_vector_int_mul (gsl_vector_int * a, const gsl_vector_int * b); ++int gsl_vector_int_div (gsl_vector_int * a, const gsl_vector_int * b); ++int gsl_vector_int_scale (gsl_vector_int * a, const double x); ++int gsl_vector_int_add_constant (gsl_vector_int * a, const double x); ++ ++int gsl_vector_int_equal (const gsl_vector_int * u, ++ const gsl_vector_int * v); ++ ++int gsl_vector_int_isnull (const gsl_vector_int * v); ++int gsl_vector_int_ispos (const gsl_vector_int * v); ++int gsl_vector_int_isneg (const gsl_vector_int * v); ++int gsl_vector_int_isnonneg (const gsl_vector_int * v); ++ ++INLINE_DECL int gsl_vector_int_get (const gsl_vector_int * v, const size_t i); ++INLINE_DECL void gsl_vector_int_set (gsl_vector_int * v, const size_t i, int x); ++INLINE_DECL int * gsl_vector_int_ptr (gsl_vector_int * v, const size_t i); ++INLINE_DECL const int * gsl_vector_int_const_ptr (const gsl_vector_int * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++int ++gsl_vector_int_get (const gsl_vector_int * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_int_set (gsl_vector_int * v, const size_t i, int x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++int * ++gsl_vector_int_ptr (gsl_vector_int * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (int *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const int * ++gsl_vector_int_const_ptr (const gsl_vector_int * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const int *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_INT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h (revision 14078) +@@ -0,0 +1,67 @@ ++/* gsl_inline.h ++ * ++ * Copyright (C) 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_INLINE_H__ ++#define __GSL_INLINE_H__ ++ ++/* In recent versiions of GCC, the inline keyword has two different ++ forms: GNU and C99. ++ ++ In GNU mode we can use 'extern inline' to make inline functions ++ work like macros. The function is only inlined--it is never output ++ as a definition in an object file. ++ ++ In the new C99 mode 'extern inline' has a different meaning--it ++ causes the definition of the function to be output in each object ++ file where it is used. This will result in multiple-definition ++ errors on linking. The 'inline' keyword on its own (without ++ extern) has the same behavior as the original GNU 'extern inline'. ++ ++ The C99 style is the default with -std=c99 in GCC 4.3. ++ ++ This header file allows either form of inline to be used by ++ redefining the macros INLINE_DECL and INLINE_FUN. These are used ++ in the public header files as ++ ++ INLINE_DECL double gsl_foo (double x); ++ #ifdef HAVE_INLINE ++ INLINE_FUN double gsl_foo (double x) { return x+1.0; } ; ++ #endif ++ ++*/ ++ ++#ifdef HAVE_INLINE ++# if defined(__GNUC_STDC_INLINE__) || defined(GSL_C99_INLINE) || defined(HAVE_C99_INLINE) ++# define INLINE_DECL inline /* use C99 inline */ ++# define INLINE_FUN inline ++# else ++# define INLINE_DECL /* use GNU extern inline */ ++# define INLINE_FUN extern inline ++# endif ++#else ++# define INLINE_DECL /* */ ++#endif ++ ++/* Range checking conditions in headers do not require any run-time ++ tests of the global variable gsl_check_range. They are enabled or ++ disabled in user code at compile time with GSL_RANGE_CHECK macro. ++ See also build.h. */ ++#define GSL_RANGE_COND(x) (x) ++ ++#endif /* __GSL_INLINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_INT_H__ ++#define __GSL_MATRIX_INT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ int * data; ++ gsl_block_int * block; ++ int owner; ++} gsl_matrix_int; ++ ++typedef struct ++{ ++ gsl_matrix_int matrix; ++} _gsl_matrix_int_view; ++ ++typedef _gsl_matrix_int_view gsl_matrix_int_view; ++ ++typedef struct ++{ ++ gsl_matrix_int matrix; ++} _gsl_matrix_int_const_view; ++ ++typedef const _gsl_matrix_int_const_view gsl_matrix_int_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_int * ++gsl_matrix_int_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_int * ++gsl_matrix_int_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_int * ++gsl_matrix_int_alloc_from_block (gsl_block_int * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_int * ++gsl_matrix_int_alloc_from_matrix (gsl_matrix_int * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_int * ++gsl_vector_int_alloc_row_from_matrix (gsl_matrix_int * m, ++ const size_t i); ++ ++gsl_vector_int * ++gsl_vector_int_alloc_col_from_matrix (gsl_matrix_int * m, ++ const size_t j); ++ ++void gsl_matrix_int_free (gsl_matrix_int * m); ++ ++/* Views */ ++ ++_gsl_matrix_int_view ++gsl_matrix_int_submatrix (gsl_matrix_int * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_int_view ++gsl_matrix_int_row (gsl_matrix_int * m, const size_t i); ++ ++_gsl_vector_int_view ++gsl_matrix_int_column (gsl_matrix_int * m, const size_t j); ++ ++_gsl_vector_int_view ++gsl_matrix_int_diagonal (gsl_matrix_int * m); ++ ++_gsl_vector_int_view ++gsl_matrix_int_subdiagonal (gsl_matrix_int * m, const size_t k); ++ ++_gsl_vector_int_view ++gsl_matrix_int_superdiagonal (gsl_matrix_int * m, const size_t k); ++ ++_gsl_vector_int_view ++gsl_matrix_int_subrow (gsl_matrix_int * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_int_view ++gsl_matrix_int_subcolumn (gsl_matrix_int * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_int_view ++gsl_matrix_int_view_array (int * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_int_view ++gsl_matrix_int_view_array_with_tda (int * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_int_view ++gsl_matrix_int_view_vector (gsl_vector_int * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_int_view ++gsl_matrix_int_view_vector_with_tda (gsl_vector_int * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_int_const_view ++gsl_matrix_int_const_submatrix (const gsl_matrix_int * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_row (const gsl_matrix_int * m, ++ const size_t i); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_column (const gsl_matrix_int * m, ++ const size_t j); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_diagonal (const gsl_matrix_int * m); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_subdiagonal (const gsl_matrix_int * m, ++ const size_t k); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_superdiagonal (const gsl_matrix_int * m, ++ const size_t k); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_subrow (const gsl_matrix_int * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_int_const_view ++gsl_matrix_int_const_subcolumn (const gsl_matrix_int * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_int_const_view ++gsl_matrix_int_const_view_array (const int * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_int_const_view ++gsl_matrix_int_const_view_array_with_tda (const int * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_int_const_view ++gsl_matrix_int_const_view_vector (const gsl_vector_int * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_int_const_view ++gsl_matrix_int_const_view_vector_with_tda (const gsl_vector_int * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_int_set_zero (gsl_matrix_int * m); ++void gsl_matrix_int_set_identity (gsl_matrix_int * m); ++void gsl_matrix_int_set_all (gsl_matrix_int * m, int x); ++ ++int gsl_matrix_int_fread (FILE * stream, gsl_matrix_int * m) ; ++int gsl_matrix_int_fwrite (FILE * stream, const gsl_matrix_int * m) ; ++int gsl_matrix_int_fscanf (FILE * stream, gsl_matrix_int * m); ++int gsl_matrix_int_fprintf (FILE * stream, const gsl_matrix_int * m, const char * format); ++ ++int gsl_matrix_int_memcpy(gsl_matrix_int * dest, const gsl_matrix_int * src); ++int gsl_matrix_int_swap(gsl_matrix_int * m1, gsl_matrix_int * m2); ++ ++int gsl_matrix_int_swap_rows(gsl_matrix_int * m, const size_t i, const size_t j); ++int gsl_matrix_int_swap_columns(gsl_matrix_int * m, const size_t i, const size_t j); ++int gsl_matrix_int_swap_rowcol(gsl_matrix_int * m, const size_t i, const size_t j); ++int gsl_matrix_int_transpose (gsl_matrix_int * m); ++int gsl_matrix_int_transpose_memcpy (gsl_matrix_int * dest, const gsl_matrix_int * src); ++ ++int gsl_matrix_int_max (const gsl_matrix_int * m); ++int gsl_matrix_int_min (const gsl_matrix_int * m); ++void gsl_matrix_int_minmax (const gsl_matrix_int * m, int * min_out, int * max_out); ++ ++void gsl_matrix_int_max_index (const gsl_matrix_int * m, size_t * imax, size_t *jmax); ++void gsl_matrix_int_min_index (const gsl_matrix_int * m, size_t * imin, size_t *jmin); ++void gsl_matrix_int_minmax_index (const gsl_matrix_int * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_int_equal (const gsl_matrix_int * a, const gsl_matrix_int * b); ++ ++int gsl_matrix_int_isnull (const gsl_matrix_int * m); ++int gsl_matrix_int_ispos (const gsl_matrix_int * m); ++int gsl_matrix_int_isneg (const gsl_matrix_int * m); ++int gsl_matrix_int_isnonneg (const gsl_matrix_int * m); ++ ++int gsl_matrix_int_add (gsl_matrix_int * a, const gsl_matrix_int * b); ++int gsl_matrix_int_sub (gsl_matrix_int * a, const gsl_matrix_int * b); ++int gsl_matrix_int_mul_elements (gsl_matrix_int * a, const gsl_matrix_int * b); ++int gsl_matrix_int_div_elements (gsl_matrix_int * a, const gsl_matrix_int * b); ++int gsl_matrix_int_scale (gsl_matrix_int * a, const double x); ++int gsl_matrix_int_add_constant (gsl_matrix_int * a, const double x); ++int gsl_matrix_int_add_diagonal (gsl_matrix_int * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_int_get_row(gsl_vector_int * v, const gsl_matrix_int * m, const size_t i); ++int gsl_matrix_int_get_col(gsl_vector_int * v, const gsl_matrix_int * m, const size_t j); ++int gsl_matrix_int_set_row(gsl_matrix_int * m, const size_t i, const gsl_vector_int * v); ++int gsl_matrix_int_set_col(gsl_matrix_int * m, const size_t j, const gsl_vector_int * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL int gsl_matrix_int_get(const gsl_matrix_int * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_int_set(gsl_matrix_int * m, const size_t i, const size_t j, const int x); ++INLINE_DECL int * gsl_matrix_int_ptr(gsl_matrix_int * m, const size_t i, const size_t j); ++INLINE_DECL const int * gsl_matrix_int_const_ptr(const gsl_matrix_int * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++int ++gsl_matrix_int_get(const gsl_matrix_int * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_int_set(gsl_matrix_int * m, const size_t i, const size_t j, const int x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++int * ++gsl_matrix_int_ptr(gsl_matrix_int * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (int *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const int * ++gsl_matrix_int_const_ptr(const gsl_matrix_int * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const int *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ ++#define __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_complex_float (const gsl_permutation * p, gsl_vector_complex_float * v); ++int gsl_permute_vector_complex_float_inverse (const gsl_permutation * p, gsl_vector_complex_float * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h (revision 14078) +@@ -0,0 +1,87 @@ ++/* dht/gsl_dht.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman ++ */ ++#ifndef __GSL_DHT_H__ ++#define __GSL_DHT_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++struct gsl_dht_struct { ++ size_t size; /* size of the sample arrays to be transformed */ ++ double nu; /* Bessel function order */ ++ double xmax; /* the upper limit to the x-sampling domain */ ++ double kmax; /* the upper limit to the k-sampling domain */ ++ double * j; /* array of computed J_nu zeros, j_{nu,s} = j[s] */ ++ double * Jjj; /* transform numerator, J_nu(j_i j_m / j_N) */ ++ double * J2; /* transform denominator, J_{nu+1}^2(j_m) */ ++}; ++typedef struct gsl_dht_struct gsl_dht; ++ ++ ++/* Create a new transform object for a given size ++ * sampling array on the domain [0, xmax]. ++ */ ++gsl_dht * gsl_dht_alloc(size_t size); ++gsl_dht * gsl_dht_new(size_t size, double nu, double xmax); ++ ++/* Recalculate a transform object for given values of nu, xmax. ++ * You cannot change the size of the object since the internal ++ * allocation is reused. ++ */ ++int gsl_dht_init(gsl_dht * t, double nu, double xmax); ++ ++/* The n'th computed x sample point for a given transform. ++ * 0 <= n <= size-1 ++ */ ++double gsl_dht_x_sample(const gsl_dht * t, int n); ++ ++ ++/* The n'th computed k sample point for a given transform. ++ * 0 <= n <= size-1 ++ */ ++double gsl_dht_k_sample(const gsl_dht * t, int n); ++ ++ ++/* Free a transform object. ++ */ ++void gsl_dht_free(gsl_dht * t); ++ ++ ++/* Perform a transform on a sampled array. ++ * f_in[0] ... f_in[size-1] and similarly for f_out[] ++ */ ++int gsl_dht_apply(const gsl_dht * t, double * f_in, double * f_out); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_DHT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h (revision 14078) +@@ -0,0 +1,55 @@ ++/* monte/gsl_monte.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Some things common to all the Monte-Carlo implementations */ ++/* Author: MJB */ ++ ++#ifndef __GSL_MONTE_H__ ++#define __GSL_MONTE_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Hide the function type in a typedef so that we can use it in all our ++ integration functions, and make it easy to change things. ++*/ ++ ++struct gsl_monte_function_struct { ++ double (*f)(double * x_array, size_t dim, void * params); ++ size_t dim; ++ void * params; ++}; ++ ++typedef struct gsl_monte_function_struct gsl_monte_function; ++ ++#define GSL_MONTE_FN_EVAL(F,x) (*((F)->f))(x,(F)->dim,(F)->params) ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_MONTE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h (revision 14078) +@@ -0,0 +1,52 @@ ++/* specfunc/gsl_sf_clausen.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_CLAUSEN_H__ ++#define __GSL_SF_CLAUSEN_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Calculate the Clausen integral: ++ * Cl_2(x) := Integrate[-Log[2 Sin[t/2]], {t,0,x}] ++ * ++ * Relation to dilogarithm: ++ * Cl_2(theta) = Im[ Li_2(e^(i theta)) ] ++ */ ++int gsl_sf_clausen_e(double x, gsl_sf_result * result); ++double gsl_sf_clausen(const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_CLAUSEN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_LONG_DOUBLE_H__ ++#define __GSL_SORT_VECTOR_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_long_double (gsl_vector_long_double * v); ++int gsl_sort_vector_long_double_index (gsl_permutation * p, const gsl_vector_long_double * v); ++ ++int gsl_sort_vector_long_double_smallest (long double * dest, const size_t k, const gsl_vector_long_double * v); ++int gsl_sort_vector_long_double_largest (long double * dest, const size_t k, const gsl_vector_long_double * v); ++ ++int gsl_sort_vector_long_double_smallest_index (size_t * p, const size_t k, const gsl_vector_long_double * v); ++int gsl_sort_vector_long_double_largest_index (size_t * p, const size_t k, const gsl_vector_long_double * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h (revision 14078) +@@ -0,0 +1,52 @@ ++/* specfunc/gsl_sf_dawson.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_DAWSON_H__ ++#define __GSL_SF_DAWSON_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Dawson's integral: ++ * ++ * Exp[-x^2] Integral[ Exp[t^2], {t,0,x}] ++ * ++ * exceptions: GSL_EUNDRFLW; ++ */ ++int gsl_sf_dawson_e(double x, gsl_sf_result * result); ++double gsl_sf_dawson(double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_DAWSON_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h (revision 14078) +@@ -0,0 +1,113 @@ ++/* specfunc/gsl_sf_psi.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_PSI_H__ ++#define __GSL_SF_PSI_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Poly-Gamma Functions ++ * ++ * psi(m,x) := (d/dx)^m psi(0,x) = (d/dx)^{m+1} log(gamma(x)) ++ */ ++ ++ ++/* Di-Gamma Function psi(n) = psi(0,n) ++ * ++ * n > 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_psi_int_e(const int n, gsl_sf_result * result); ++double gsl_sf_psi_int(const int n); ++ ++ ++/* Di-Gamma Function psi(x) = psi(0, x) ++ * ++ * x != 0.0, -1.0, -2.0, ... ++ * exceptions: GSL_EDOM, GSL_ELOSS ++ */ ++int gsl_sf_psi_e(const double x, gsl_sf_result * result); ++double gsl_sf_psi(const double x); ++ ++ ++/* Di-Gamma Function Re[psi(1 + I y)] ++ * ++ * exceptions: none ++ */ ++int gsl_sf_psi_1piy_e(const double y, gsl_sf_result * result); ++double gsl_sf_psi_1piy(const double y); ++ ++ ++/* Di-Gamma Function psi(z) for general complex argument z = x + iy ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_complex_psi_e( ++ const double x, ++ const double y, ++ gsl_sf_result * result_re, ++ gsl_sf_result * result_im ++ ); ++ ++ ++/* Tri-Gamma Function psi^(1)(n) ++ * ++ * n > 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_psi_1_int_e(const int n, gsl_sf_result * result); ++double gsl_sf_psi_1_int(const int n); ++ ++ ++/* Tri-Gamma Function psi^(1)(x) ++ * ++ * x != 0.0, -1.0, -2.0, ... ++ * exceptions: GSL_EDOM, GSL_ELOSS ++ */ ++int gsl_sf_psi_1_e(const double x, gsl_sf_result * result); ++double gsl_sf_psi_1(const double x); ++ ++ ++/* Poly-Gamma Function psi^(n)(x) ++ * ++ * n >= 0, x > 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_psi_n_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_psi_n(const int n, const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_PSI_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_complex_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ ++#define __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_complex (const gsl_permutation * p, gsl_vector_complex * v); ++int gsl_permute_vector_complex_inverse (const gsl_permutation * p, gsl_vector_complex * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h (revision 14078) +@@ -0,0 +1,80 @@ ++/* err/gsl_message.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MESSAGE_H__ ++#define __GSL_MESSAGE_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Provide a general messaging service for client use. Messages can ++ * be selectively turned off at compile time by defining an ++ * appropriate message mask. Client code which uses the GSL_MESSAGE() ++ * macro must provide a mask which is or'ed with the GSL_MESSAGE_MASK. ++ * ++ * The messaging service can be completely turned off ++ * by defining GSL_MESSAGING_OFF. */ ++ ++void gsl_message(const char * message, const char * file, int line, ++ unsigned int mask); ++ ++#ifndef GSL_MESSAGE_MASK ++#define GSL_MESSAGE_MASK 0xffffffffu /* default all messages allowed */ ++#endif ++ ++GSL_VAR unsigned int gsl_message_mask ; ++ ++/* Provide some symolic masks for client ease of use. */ ++ ++enum { ++ GSL_MESSAGE_MASK_A = 1, ++ GSL_MESSAGE_MASK_B = 2, ++ GSL_MESSAGE_MASK_C = 4, ++ GSL_MESSAGE_MASK_D = 8, ++ GSL_MESSAGE_MASK_E = 16, ++ GSL_MESSAGE_MASK_F = 32, ++ GSL_MESSAGE_MASK_G = 64, ++ GSL_MESSAGE_MASK_H = 128 ++} ; ++ ++#ifdef GSL_MESSAGING_OFF /* throw away messages */ ++#define GSL_MESSAGE(message, mask) do { } while(0) ++#else /* output all messages */ ++#define GSL_MESSAGE(message, mask) \ ++ do { \ ++ if (mask & GSL_MESSAGE_MASK) \ ++ gsl_message (message, __FILE__, __LINE__, mask) ; \ ++ } while (0) ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MESSAGE_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h (revision 14078) +@@ -0,0 +1,78 @@ ++/* specfunc/gsl_sf_transport.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_TRANSPORT_H__ ++#define __GSL_SF_TRANSPORT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Transport function: ++ * J(n,x) := Integral[ t^n e^t /(e^t - 1)^2, {t,0,x}] ++ */ ++ ++/* J(2,x) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_transport_2_e(const double x, gsl_sf_result * result); ++double gsl_sf_transport_2(const double x); ++ ++ ++/* J(3,x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_transport_3_e(const double x, gsl_sf_result * result); ++double gsl_sf_transport_3(const double x); ++ ++ ++/* J(4,x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_transport_4_e(const double x, gsl_sf_result * result); ++double gsl_sf_transport_4(const double x); ++ ++ ++/* J(5,x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_transport_5_e(const double x, gsl_sf_result * result); ++double gsl_sf_transport_5(const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_TRANSPORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h (revision 14078) +@@ -0,0 +1,217 @@ ++/* rng/gsl_rng.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 James Theiler, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_RNG_H__ ++#define __GSL_RNG_H__ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++ { ++ const char *name; ++ unsigned long int max; ++ unsigned long int min; ++ size_t size; ++ void (*set) (void *state, unsigned long int seed); ++ unsigned long int (*get) (void *state); ++ double (*get_double) (void *state); ++ } ++gsl_rng_type; ++ ++typedef struct ++ { ++ const gsl_rng_type * type; ++ void *state; ++ } ++gsl_rng; ++ ++ ++/* These structs also need to appear in default.c so you can select ++ them via the environment variable GSL_RNG_TYPE */ ++ ++GSL_VAR const gsl_rng_type *gsl_rng_borosh13; ++GSL_VAR const gsl_rng_type *gsl_rng_coveyou; ++GSL_VAR const gsl_rng_type *gsl_rng_cmrg; ++GSL_VAR const gsl_rng_type *gsl_rng_fishman18; ++GSL_VAR const gsl_rng_type *gsl_rng_fishman20; ++GSL_VAR const gsl_rng_type *gsl_rng_fishman2x; ++GSL_VAR const gsl_rng_type *gsl_rng_gfsr4; ++GSL_VAR const gsl_rng_type *gsl_rng_knuthran; ++GSL_VAR const gsl_rng_type *gsl_rng_knuthran2; ++GSL_VAR const gsl_rng_type *gsl_rng_knuthran2002; ++GSL_VAR const gsl_rng_type *gsl_rng_lecuyer21; ++GSL_VAR const gsl_rng_type *gsl_rng_minstd; ++GSL_VAR const gsl_rng_type *gsl_rng_mrg; ++GSL_VAR const gsl_rng_type *gsl_rng_mt19937; ++GSL_VAR const gsl_rng_type *gsl_rng_mt19937_1999; ++GSL_VAR const gsl_rng_type *gsl_rng_mt19937_1998; ++GSL_VAR const gsl_rng_type *gsl_rng_r250; ++GSL_VAR const gsl_rng_type *gsl_rng_ran0; ++GSL_VAR const gsl_rng_type *gsl_rng_ran1; ++GSL_VAR const gsl_rng_type *gsl_rng_ran2; ++GSL_VAR const gsl_rng_type *gsl_rng_ran3; ++GSL_VAR const gsl_rng_type *gsl_rng_rand; ++GSL_VAR const gsl_rng_type *gsl_rng_rand48; ++GSL_VAR const gsl_rng_type *gsl_rng_random128_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random128_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random128_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_random256_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random256_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random256_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_random32_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random32_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random32_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_random64_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random64_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random64_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_random8_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random8_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random8_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_random_bsd; ++GSL_VAR const gsl_rng_type *gsl_rng_random_glibc2; ++GSL_VAR const gsl_rng_type *gsl_rng_random_libc5; ++GSL_VAR const gsl_rng_type *gsl_rng_randu; ++GSL_VAR const gsl_rng_type *gsl_rng_ranf; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlux; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlux389; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlxd1; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlxd2; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlxs0; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlxs1; ++GSL_VAR const gsl_rng_type *gsl_rng_ranlxs2; ++GSL_VAR const gsl_rng_type *gsl_rng_ranmar; ++GSL_VAR const gsl_rng_type *gsl_rng_slatec; ++GSL_VAR const gsl_rng_type *gsl_rng_taus; ++GSL_VAR const gsl_rng_type *gsl_rng_taus2; ++GSL_VAR const gsl_rng_type *gsl_rng_taus113; ++GSL_VAR const gsl_rng_type *gsl_rng_transputer; ++GSL_VAR const gsl_rng_type *gsl_rng_tt800; ++GSL_VAR const gsl_rng_type *gsl_rng_uni; ++GSL_VAR const gsl_rng_type *gsl_rng_uni32; ++GSL_VAR const gsl_rng_type *gsl_rng_vax; ++GSL_VAR const gsl_rng_type *gsl_rng_waterman14; ++GSL_VAR const gsl_rng_type *gsl_rng_zuf; ++ ++const gsl_rng_type ** gsl_rng_types_setup(void); ++ ++GSL_VAR const gsl_rng_type *gsl_rng_default; ++GSL_VAR unsigned long int gsl_rng_default_seed; ++ ++gsl_rng *gsl_rng_alloc (const gsl_rng_type * T); ++int gsl_rng_memcpy (gsl_rng * dest, const gsl_rng * src); ++gsl_rng *gsl_rng_clone (const gsl_rng * r); ++ ++void gsl_rng_free (gsl_rng * r); ++ ++void gsl_rng_set (const gsl_rng * r, unsigned long int seed); ++unsigned long int gsl_rng_max (const gsl_rng * r); ++unsigned long int gsl_rng_min (const gsl_rng * r); ++const char *gsl_rng_name (const gsl_rng * r); ++ ++int gsl_rng_fread (FILE * stream, gsl_rng * r); ++int gsl_rng_fwrite (FILE * stream, const gsl_rng * r); ++ ++size_t gsl_rng_size (const gsl_rng * r); ++void * gsl_rng_state (const gsl_rng * r); ++ ++void gsl_rng_print_state (const gsl_rng * r); ++ ++const gsl_rng_type * gsl_rng_env_setup (void); ++ ++INLINE_DECL unsigned long int gsl_rng_get (const gsl_rng * r); ++INLINE_DECL double gsl_rng_uniform (const gsl_rng * r); ++INLINE_DECL double gsl_rng_uniform_pos (const gsl_rng * r); ++INLINE_DECL unsigned long int gsl_rng_uniform_int (const gsl_rng * r, unsigned long int n); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN unsigned long int ++gsl_rng_get (const gsl_rng * r) ++{ ++ return (r->type->get) (r->state); ++} ++ ++INLINE_FUN double ++gsl_rng_uniform (const gsl_rng * r) ++{ ++ return (r->type->get_double) (r->state); ++} ++ ++INLINE_FUN double ++gsl_rng_uniform_pos (const gsl_rng * r) ++{ ++ double x ; ++ do ++ { ++ x = (r->type->get_double) (r->state) ; ++ } ++ while (x == 0) ; ++ ++ return x ; ++} ++ ++/* Note: to avoid integer overflow in (range+1) we work with scale = ++ range/n = (max-min)/n rather than scale=(max-min+1)/n, this reduces ++ efficiency slightly but avoids having to check for the out of range ++ value. Note that range is typically O(2^32) so the addition of 1 ++ is negligible in most usage. */ ++ ++INLINE_FUN unsigned long int ++gsl_rng_uniform_int (const gsl_rng * r, unsigned long int n) ++{ ++ unsigned long int offset = r->type->min; ++ unsigned long int range = r->type->max - offset; ++ unsigned long int scale; ++ unsigned long int k; ++ ++ if (n > range || n == 0) ++ { ++ GSL_ERROR_VAL ("invalid n, either 0 or exceeds maximum value of generator", ++ GSL_EINVAL, 0) ; ++ } ++ ++ scale = range / n; ++ ++ do ++ { ++ k = (((r->type->get) (r->state)) - offset) / scale; ++ } ++ while (k >= n); ++ ++ return k; ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_RNG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h (revision 14078) +@@ -0,0 +1,128 @@ ++/* specfunc/gsl_sf_coulomb.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_COULOMB_H__ ++#define __GSL_SF_COULOMB_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Normalized hydrogenic bound states, radial dependence. */ ++ ++/* R_1 := 2Z sqrt(Z) exp(-Z r) ++ */ ++int gsl_sf_hydrogenicR_1_e(const double Z, const double r, gsl_sf_result * result); ++double gsl_sf_hydrogenicR_1(const double Z, const double r); ++ ++/* R_n := norm exp(-Z r/n) (2Z/n)^l Laguerre[n-l-1, 2l+1, 2Z/n r] ++ * ++ * normalization such that psi(n,l,r) = R_n Y_{lm} ++ */ ++int gsl_sf_hydrogenicR_e(const int n, const int l, const double Z, const double r, gsl_sf_result * result); ++double gsl_sf_hydrogenicR(const int n, const int l, const double Z, const double r); ++ ++ ++/* Coulomb wave functions F_{lam_F}(eta,x), G_{lam_G}(eta,x) ++ * and their derivatives; lam_G := lam_F - k_lam_G ++ * ++ * lam_F, lam_G > -0.5 ++ * x > 0.0 ++ * ++ * Conventions of Abramowitz+Stegun. ++ * ++ * Because there can be a large dynamic range of values, ++ * overflows are handled gracefully. If an overflow occurs, ++ * GSL_EOVRFLW is signalled and exponent(s) are returned ++ * through exp_F, exp_G. These are such that ++ * ++ * F_L(eta,x) = fc[k_L] * exp(exp_F) ++ * G_L(eta,x) = gc[k_L] * exp(exp_G) ++ * F_L'(eta,x) = fcp[k_L] * exp(exp_F) ++ * G_L'(eta,x) = gcp[k_L] * exp(exp_G) ++ */ ++int ++gsl_sf_coulomb_wave_FG_e(const double eta, const double x, ++ const double lam_F, ++ const int k_lam_G, ++ gsl_sf_result * F, gsl_sf_result * Fp, ++ gsl_sf_result * G, gsl_sf_result * Gp, ++ double * exp_F, double * exp_G); ++ ++ ++/* F_L(eta,x) as array */ ++int gsl_sf_coulomb_wave_F_array( ++ double lam_min, int kmax, ++ double eta, double x, ++ double * fc_array, ++ double * F_exponent ++ ); ++ ++/* F_L(eta,x), G_L(eta,x) as arrays */ ++int gsl_sf_coulomb_wave_FG_array(double lam_min, int kmax, ++ double eta, double x, ++ double * fc_array, double * gc_array, ++ double * F_exponent, ++ double * G_exponent ++ ); ++ ++/* F_L(eta,x), G_L(eta,x), F'_L(eta,x), G'_L(eta,x) as arrays */ ++int gsl_sf_coulomb_wave_FGp_array(double lam_min, int kmax, ++ double eta, double x, ++ double * fc_array, double * fcp_array, ++ double * gc_array, double * gcp_array, ++ double * F_exponent, ++ double * G_exponent ++ ); ++ ++/* Coulomb wave function divided by the argument, ++ * F(eta, x)/x. This is the function which reduces to ++ * spherical Bessel functions in the limit eta->0. ++ */ ++int gsl_sf_coulomb_wave_sphF_array(double lam_min, int kmax, ++ double eta, double x, ++ double * fc_array, ++ double * F_exponent ++ ); ++ ++ ++/* Coulomb wave function normalization constant. ++ * [Abramowitz+Stegun 14.1.8, 14.1.9] ++ */ ++int gsl_sf_coulomb_CL_e(double L, double eta, gsl_sf_result * result); ++int gsl_sf_coulomb_CL_array(double Lmin, int kmax, double eta, double * cl); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_COULOMB_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_SHORT_H__ ++#define __GSL_SORT_VECTOR_SHORT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_short (gsl_vector_short * v); ++int gsl_sort_vector_short_index (gsl_permutation * p, const gsl_vector_short * v); ++ ++int gsl_sort_vector_short_smallest (short * dest, const size_t k, const gsl_vector_short * v); ++int gsl_sort_vector_short_largest (short * dest, const size_t k, const gsl_vector_short * v); ++ ++int gsl_sort_vector_short_smallest_index (size_t * p, const size_t k, const gsl_vector_short * v); ++int gsl_sort_vector_short_largest_index (size_t * p, const size_t k, const gsl_vector_short * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_ULONG_H__ ++#define __GSL_STATISTICS_ULONG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_ulong_mean (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_variance (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_sd (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_variance_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ulong_sd_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ulong_tss (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_tss_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_ulong_absdev (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_skew (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_kurtosis (const unsigned long data[], const size_t stride, const size_t n); ++double gsl_stats_ulong_lag1_autocorrelation (const unsigned long data[], const size_t stride, const size_t n); ++ ++double gsl_stats_ulong_covariance (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n); ++double gsl_stats_ulong_correlation (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_ulong_variance_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ulong_sd_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ulong_absdev_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ulong_skew_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_ulong_kurtosis_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_ulong_lag1_autocorrelation_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_ulong_covariance_m (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_ulong_pvariance (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2); ++double gsl_stats_ulong_ttest (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2); ++ ++unsigned long gsl_stats_ulong_max (const unsigned long data[], const size_t stride, const size_t n); ++unsigned long gsl_stats_ulong_min (const unsigned long data[], const size_t stride, const size_t n); ++void gsl_stats_ulong_minmax (unsigned long * min, unsigned long * max, const unsigned long data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_ulong_max_index (const unsigned long data[], const size_t stride, const size_t n); ++size_t gsl_stats_ulong_min_index (const unsigned long data[], const size_t stride, const size_t n); ++void gsl_stats_ulong_minmax_index (size_t * min_index, size_t * max_index, const unsigned long data[], const size_t stride, const size_t n); ++ ++double gsl_stats_ulong_median_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_ulong_quantile_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h (revision 14078) +@@ -0,0 +1,92 @@ ++/* combination/gsl_combination.h ++ * based on permutation/gsl_permutation.h by Brian Gough ++ * ++ * Copyright (C) 2001 Szymon Jaroszewicz ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_COMBINATION_H__ ++#define __GSL_COMBINATION_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_combination_struct ++{ ++ size_t n; ++ size_t k; ++ size_t *data; ++}; ++ ++typedef struct gsl_combination_struct gsl_combination; ++ ++gsl_combination *gsl_combination_alloc (const size_t n, const size_t k); ++gsl_combination *gsl_combination_calloc (const size_t n, const size_t k); ++void gsl_combination_init_first (gsl_combination * c); ++void gsl_combination_init_last (gsl_combination * c); ++void gsl_combination_free (gsl_combination * c); ++int gsl_combination_memcpy (gsl_combination * dest, const gsl_combination * src); ++ ++int gsl_combination_fread (FILE * stream, gsl_combination * c); ++int gsl_combination_fwrite (FILE * stream, const gsl_combination * c); ++int gsl_combination_fscanf (FILE * stream, gsl_combination * c); ++int gsl_combination_fprintf (FILE * stream, const gsl_combination * c, const char *format); ++ ++size_t gsl_combination_n (const gsl_combination * c); ++size_t gsl_combination_k (const gsl_combination * c); ++size_t * gsl_combination_data (const gsl_combination * c); ++ ++int gsl_combination_valid (gsl_combination * c); ++int gsl_combination_next (gsl_combination * c); ++int gsl_combination_prev (gsl_combination * c); ++ ++INLINE_DECL size_t gsl_combination_get (const gsl_combination * c, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++size_t ++gsl_combination_get (const gsl_combination * c, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= c->k)) /* size_t is unsigned, can't be negative */ ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return c->data[i]; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_COMBINATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h (revision 14078) +@@ -0,0 +1,43 @@ ++/* const/gsl_const_num.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, ++ * 2006, 2007, 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST_NUM__ ++#define __GSL_CONST_NUM__ ++ ++#define GSL_CONST_NUM_FINE_STRUCTURE (7.297352533e-3) /* 1 */ ++#define GSL_CONST_NUM_AVOGADRO (6.02214199e23) /* 1 / mol */ ++#define GSL_CONST_NUM_YOTTA (1e24) /* 1 */ ++#define GSL_CONST_NUM_ZETTA (1e21) /* 1 */ ++#define GSL_CONST_NUM_EXA (1e18) /* 1 */ ++#define GSL_CONST_NUM_PETA (1e15) /* 1 */ ++#define GSL_CONST_NUM_TERA (1e12) /* 1 */ ++#define GSL_CONST_NUM_GIGA (1e9) /* 1 */ ++#define GSL_CONST_NUM_MEGA (1e6) /* 1 */ ++#define GSL_CONST_NUM_KILO (1e3) /* 1 */ ++#define GSL_CONST_NUM_MILLI (1e-3) /* 1 */ ++#define GSL_CONST_NUM_MICRO (1e-6) /* 1 */ ++#define GSL_CONST_NUM_NANO (1e-9) /* 1 */ ++#define GSL_CONST_NUM_PICO (1e-12) /* 1 */ ++#define GSL_CONST_NUM_FEMTO (1e-15) /* 1 */ ++#define GSL_CONST_NUM_ATTO (1e-18) /* 1 */ ++#define GSL_CONST_NUM_ZEPTO (1e-21) /* 1 */ ++#define GSL_CONST_NUM_YOCTO (1e-24) /* 1 */ ++ ++#endif /* __GSL_CONST_NUM__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_COMPLEX_FLOAT_H__ ++#define __GSL_BLOCK_COMPLEX_FLOAT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_complex_float_struct ++{ ++ size_t size; ++ float *data; ++}; ++ ++typedef struct gsl_block_complex_float_struct gsl_block_complex_float; ++ ++gsl_block_complex_float *gsl_block_complex_float_alloc (const size_t n); ++gsl_block_complex_float *gsl_block_complex_float_calloc (const size_t n); ++void gsl_block_complex_float_free (gsl_block_complex_float * b); ++ ++int gsl_block_complex_float_fread (FILE * stream, gsl_block_complex_float * b); ++int gsl_block_complex_float_fwrite (FILE * stream, const gsl_block_complex_float * b); ++int gsl_block_complex_float_fscanf (FILE * stream, gsl_block_complex_float * b); ++int gsl_block_complex_float_fprintf (FILE * stream, const gsl_block_complex_float * b, const char *format); ++ ++int gsl_block_complex_float_raw_fread (FILE * stream, float * b, const size_t n, const size_t stride); ++int gsl_block_complex_float_raw_fwrite (FILE * stream, const float * b, const size_t n, const size_t stride); ++int gsl_block_complex_float_raw_fscanf (FILE * stream, float * b, const size_t n, const size_t stride); ++int gsl_block_complex_float_raw_fprintf (FILE * stream, const float * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_complex_float_size (const gsl_block_complex_float * b); ++float * gsl_block_complex_float_data (const gsl_block_complex_float * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_USHORT_H__ ++#define __GSL_VECTOR_USHORT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ unsigned short *data; ++ gsl_block_ushort *block; ++ int owner; ++} ++gsl_vector_ushort; ++ ++typedef struct ++{ ++ gsl_vector_ushort vector; ++} _gsl_vector_ushort_view; ++ ++typedef _gsl_vector_ushort_view gsl_vector_ushort_view; ++ ++typedef struct ++{ ++ gsl_vector_ushort vector; ++} _gsl_vector_ushort_const_view; ++ ++typedef const _gsl_vector_ushort_const_view gsl_vector_ushort_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_ushort *gsl_vector_ushort_alloc (const size_t n); ++gsl_vector_ushort *gsl_vector_ushort_calloc (const size_t n); ++ ++gsl_vector_ushort *gsl_vector_ushort_alloc_from_block (gsl_block_ushort * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_ushort *gsl_vector_ushort_alloc_from_vector (gsl_vector_ushort * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_ushort_free (gsl_vector_ushort * v); ++ ++/* Views */ ++ ++_gsl_vector_ushort_view ++gsl_vector_ushort_view_array (unsigned short *v, size_t n); ++ ++_gsl_vector_ushort_view ++gsl_vector_ushort_view_array_with_stride (unsigned short *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ushort_const_view ++gsl_vector_ushort_const_view_array (const unsigned short *v, size_t n); ++ ++_gsl_vector_ushort_const_view ++gsl_vector_ushort_const_view_array_with_stride (const unsigned short *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ushort_view ++gsl_vector_ushort_subvector (gsl_vector_ushort *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_ushort_view ++gsl_vector_ushort_subvector_with_stride (gsl_vector_ushort *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ushort_const_view ++gsl_vector_ushort_const_subvector (const gsl_vector_ushort *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_ushort_const_view ++gsl_vector_ushort_const_subvector_with_stride (const gsl_vector_ushort *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_ushort_set_zero (gsl_vector_ushort * v); ++void gsl_vector_ushort_set_all (gsl_vector_ushort * v, unsigned short x); ++int gsl_vector_ushort_set_basis (gsl_vector_ushort * v, size_t i); ++ ++int gsl_vector_ushort_fread (FILE * stream, gsl_vector_ushort * v); ++int gsl_vector_ushort_fwrite (FILE * stream, const gsl_vector_ushort * v); ++int gsl_vector_ushort_fscanf (FILE * stream, gsl_vector_ushort * v); ++int gsl_vector_ushort_fprintf (FILE * stream, const gsl_vector_ushort * v, ++ const char *format); ++ ++int gsl_vector_ushort_memcpy (gsl_vector_ushort * dest, const gsl_vector_ushort * src); ++ ++int gsl_vector_ushort_reverse (gsl_vector_ushort * v); ++ ++int gsl_vector_ushort_swap (gsl_vector_ushort * v, gsl_vector_ushort * w); ++int gsl_vector_ushort_swap_elements (gsl_vector_ushort * v, const size_t i, const size_t j); ++ ++unsigned short gsl_vector_ushort_max (const gsl_vector_ushort * v); ++unsigned short gsl_vector_ushort_min (const gsl_vector_ushort * v); ++void gsl_vector_ushort_minmax (const gsl_vector_ushort * v, unsigned short * min_out, unsigned short * max_out); ++ ++size_t gsl_vector_ushort_max_index (const gsl_vector_ushort * v); ++size_t gsl_vector_ushort_min_index (const gsl_vector_ushort * v); ++void gsl_vector_ushort_minmax_index (const gsl_vector_ushort * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_ushort_add (gsl_vector_ushort * a, const gsl_vector_ushort * b); ++int gsl_vector_ushort_sub (gsl_vector_ushort * a, const gsl_vector_ushort * b); ++int gsl_vector_ushort_mul (gsl_vector_ushort * a, const gsl_vector_ushort * b); ++int gsl_vector_ushort_div (gsl_vector_ushort * a, const gsl_vector_ushort * b); ++int gsl_vector_ushort_scale (gsl_vector_ushort * a, const double x); ++int gsl_vector_ushort_add_constant (gsl_vector_ushort * a, const double x); ++ ++int gsl_vector_ushort_equal (const gsl_vector_ushort * u, ++ const gsl_vector_ushort * v); ++ ++int gsl_vector_ushort_isnull (const gsl_vector_ushort * v); ++int gsl_vector_ushort_ispos (const gsl_vector_ushort * v); ++int gsl_vector_ushort_isneg (const gsl_vector_ushort * v); ++int gsl_vector_ushort_isnonneg (const gsl_vector_ushort * v); ++ ++INLINE_DECL unsigned short gsl_vector_ushort_get (const gsl_vector_ushort * v, const size_t i); ++INLINE_DECL void gsl_vector_ushort_set (gsl_vector_ushort * v, const size_t i, unsigned short x); ++INLINE_DECL unsigned short * gsl_vector_ushort_ptr (gsl_vector_ushort * v, const size_t i); ++INLINE_DECL const unsigned short * gsl_vector_ushort_const_ptr (const gsl_vector_ushort * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++unsigned short ++gsl_vector_ushort_get (const gsl_vector_ushort * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_ushort_set (gsl_vector_ushort * v, const size_t i, unsigned short x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++unsigned short * ++gsl_vector_ushort_ptr (gsl_vector_ushort * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (unsigned short *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const unsigned short * ++gsl_vector_ushort_const_ptr (const gsl_vector_ushort * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const unsigned short *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_USHORT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_ULONG_H__ ++#define __GSL_MATRIX_ULONG_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ unsigned long * data; ++ gsl_block_ulong * block; ++ int owner; ++} gsl_matrix_ulong; ++ ++typedef struct ++{ ++ gsl_matrix_ulong matrix; ++} _gsl_matrix_ulong_view; ++ ++typedef _gsl_matrix_ulong_view gsl_matrix_ulong_view; ++ ++typedef struct ++{ ++ gsl_matrix_ulong matrix; ++} _gsl_matrix_ulong_const_view; ++ ++typedef const _gsl_matrix_ulong_const_view gsl_matrix_ulong_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_ulong * ++gsl_matrix_ulong_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_ulong * ++gsl_matrix_ulong_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_ulong * ++gsl_matrix_ulong_alloc_from_block (gsl_block_ulong * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_ulong * ++gsl_matrix_ulong_alloc_from_matrix (gsl_matrix_ulong * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_ulong * ++gsl_vector_ulong_alloc_row_from_matrix (gsl_matrix_ulong * m, ++ const size_t i); ++ ++gsl_vector_ulong * ++gsl_vector_ulong_alloc_col_from_matrix (gsl_matrix_ulong * m, ++ const size_t j); ++ ++void gsl_matrix_ulong_free (gsl_matrix_ulong * m); ++ ++/* Views */ ++ ++_gsl_matrix_ulong_view ++gsl_matrix_ulong_submatrix (gsl_matrix_ulong * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_row (gsl_matrix_ulong * m, const size_t i); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_column (gsl_matrix_ulong * m, const size_t j); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_diagonal (gsl_matrix_ulong * m); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_subdiagonal (gsl_matrix_ulong * m, const size_t k); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_superdiagonal (gsl_matrix_ulong * m, const size_t k); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_subrow (gsl_matrix_ulong * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_ulong_view ++gsl_matrix_ulong_subcolumn (gsl_matrix_ulong * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_ulong_view ++gsl_matrix_ulong_view_array (unsigned long * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ulong_view ++gsl_matrix_ulong_view_array_with_tda (unsigned long * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_ulong_view ++gsl_matrix_ulong_view_vector (gsl_vector_ulong * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ulong_view ++gsl_matrix_ulong_view_vector_with_tda (gsl_vector_ulong * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_ulong_const_view ++gsl_matrix_ulong_const_submatrix (const gsl_matrix_ulong * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_row (const gsl_matrix_ulong * m, ++ const size_t i); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_column (const gsl_matrix_ulong * m, ++ const size_t j); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_diagonal (const gsl_matrix_ulong * m); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_subdiagonal (const gsl_matrix_ulong * m, ++ const size_t k); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_superdiagonal (const gsl_matrix_ulong * m, ++ const size_t k); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_subrow (const gsl_matrix_ulong * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_ulong_const_view ++gsl_matrix_ulong_const_subcolumn (const gsl_matrix_ulong * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_ulong_const_view ++gsl_matrix_ulong_const_view_array (const unsigned long * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ulong_const_view ++gsl_matrix_ulong_const_view_array_with_tda (const unsigned long * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_ulong_const_view ++gsl_matrix_ulong_const_view_vector (const gsl_vector_ulong * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_ulong_const_view ++gsl_matrix_ulong_const_view_vector_with_tda (const gsl_vector_ulong * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_ulong_set_zero (gsl_matrix_ulong * m); ++void gsl_matrix_ulong_set_identity (gsl_matrix_ulong * m); ++void gsl_matrix_ulong_set_all (gsl_matrix_ulong * m, unsigned long x); ++ ++int gsl_matrix_ulong_fread (FILE * stream, gsl_matrix_ulong * m) ; ++int gsl_matrix_ulong_fwrite (FILE * stream, const gsl_matrix_ulong * m) ; ++int gsl_matrix_ulong_fscanf (FILE * stream, gsl_matrix_ulong * m); ++int gsl_matrix_ulong_fprintf (FILE * stream, const gsl_matrix_ulong * m, const char * format); ++ ++int gsl_matrix_ulong_memcpy(gsl_matrix_ulong * dest, const gsl_matrix_ulong * src); ++int gsl_matrix_ulong_swap(gsl_matrix_ulong * m1, gsl_matrix_ulong * m2); ++ ++int gsl_matrix_ulong_swap_rows(gsl_matrix_ulong * m, const size_t i, const size_t j); ++int gsl_matrix_ulong_swap_columns(gsl_matrix_ulong * m, const size_t i, const size_t j); ++int gsl_matrix_ulong_swap_rowcol(gsl_matrix_ulong * m, const size_t i, const size_t j); ++int gsl_matrix_ulong_transpose (gsl_matrix_ulong * m); ++int gsl_matrix_ulong_transpose_memcpy (gsl_matrix_ulong * dest, const gsl_matrix_ulong * src); ++ ++unsigned long gsl_matrix_ulong_max (const gsl_matrix_ulong * m); ++unsigned long gsl_matrix_ulong_min (const gsl_matrix_ulong * m); ++void gsl_matrix_ulong_minmax (const gsl_matrix_ulong * m, unsigned long * min_out, unsigned long * max_out); ++ ++void gsl_matrix_ulong_max_index (const gsl_matrix_ulong * m, size_t * imax, size_t *jmax); ++void gsl_matrix_ulong_min_index (const gsl_matrix_ulong * m, size_t * imin, size_t *jmin); ++void gsl_matrix_ulong_minmax_index (const gsl_matrix_ulong * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_ulong_equal (const gsl_matrix_ulong * a, const gsl_matrix_ulong * b); ++ ++int gsl_matrix_ulong_isnull (const gsl_matrix_ulong * m); ++int gsl_matrix_ulong_ispos (const gsl_matrix_ulong * m); ++int gsl_matrix_ulong_isneg (const gsl_matrix_ulong * m); ++int gsl_matrix_ulong_isnonneg (const gsl_matrix_ulong * m); ++ ++int gsl_matrix_ulong_add (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); ++int gsl_matrix_ulong_sub (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); ++int gsl_matrix_ulong_mul_elements (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); ++int gsl_matrix_ulong_div_elements (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); ++int gsl_matrix_ulong_scale (gsl_matrix_ulong * a, const double x); ++int gsl_matrix_ulong_add_constant (gsl_matrix_ulong * a, const double x); ++int gsl_matrix_ulong_add_diagonal (gsl_matrix_ulong * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_ulong_get_row(gsl_vector_ulong * v, const gsl_matrix_ulong * m, const size_t i); ++int gsl_matrix_ulong_get_col(gsl_vector_ulong * v, const gsl_matrix_ulong * m, const size_t j); ++int gsl_matrix_ulong_set_row(gsl_matrix_ulong * m, const size_t i, const gsl_vector_ulong * v); ++int gsl_matrix_ulong_set_col(gsl_matrix_ulong * m, const size_t j, const gsl_vector_ulong * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL unsigned long gsl_matrix_ulong_get(const gsl_matrix_ulong * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_ulong_set(gsl_matrix_ulong * m, const size_t i, const size_t j, const unsigned long x); ++INLINE_DECL unsigned long * gsl_matrix_ulong_ptr(gsl_matrix_ulong * m, const size_t i, const size_t j); ++INLINE_DECL const unsigned long * gsl_matrix_ulong_const_ptr(const gsl_matrix_ulong * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++unsigned long ++gsl_matrix_ulong_get(const gsl_matrix_ulong * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_ulong_set(gsl_matrix_ulong * m, const size_t i, const size_t j, const unsigned long x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++unsigned long * ++gsl_matrix_ulong_ptr(gsl_matrix_ulong * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (unsigned long *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const unsigned long * ++gsl_matrix_ulong_const_ptr(const gsl_matrix_ulong * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const unsigned long *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* deriv/gsl_deriv.h ++ * ++ * Copyright (C) 2000 David Morrison ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_DERIV_H__ ++#define __GSL_DERIV_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_deriv_central (const gsl_function *f, ++ double x, double h, ++ double *result, double *abserr); ++ ++int gsl_deriv_backward (const gsl_function *f, ++ double x, double h, ++ double *result, double *abserr); ++ ++int gsl_deriv_forward (const gsl_function *f, ++ double x, double h, ++ double *result, double *abserr); ++ ++__END_DECLS ++ ++#endif /* __GSL_DERIV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_UCHAR_H__ ++#define __GSL_SORT_UCHAR_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_uchar (unsigned char * data, const size_t stride, const size_t n); ++void gsl_sort_uchar_index (size_t * p, const unsigned char * data, const size_t stride, const size_t n); ++ ++int gsl_sort_uchar_smallest (unsigned char * dest, const size_t k, const unsigned char * src, const size_t stride, const size_t n); ++int gsl_sort_uchar_smallest_index (size_t * p, const size_t k, const unsigned char * src, const size_t stride, const size_t n); ++ ++int gsl_sort_uchar_largest (unsigned char * dest, const size_t k, const unsigned char * src, const size_t stride, const size_t n); ++int gsl_sort_uchar_largest_index (size_t * p, const size_t k, const unsigned char * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h (revision 14078) +@@ -0,0 +1,293 @@ ++/* specfunc/gsl_sf_gamma.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_GAMMA_H__ ++#define __GSL_SF_GAMMA_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Log[Gamma(x)], x not a negative integer ++ * Uses real Lanczos method. ++ * Returns the real part of Log[Gamma[x]] when x < 0, ++ * i.e. Log[|Gamma[x]|]. ++ * ++ * exceptions: GSL_EDOM, GSL_EROUND ++ */ ++int gsl_sf_lngamma_e(double x, gsl_sf_result * result); ++double gsl_sf_lngamma(const double x); ++ ++ ++/* Log[Gamma(x)], x not a negative integer ++ * Uses real Lanczos method. Determines ++ * the sign of Gamma[x] as well as Log[|Gamma[x]|] for x < 0. ++ * So Gamma[x] = sgn * Exp[result_lg]. ++ * ++ * exceptions: GSL_EDOM, GSL_EROUND ++ */ ++int gsl_sf_lngamma_sgn_e(double x, gsl_sf_result * result_lg, double *sgn); ++ ++ ++/* Gamma(x), x not a negative integer ++ * Uses real Lanczos method. ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EROUND ++ */ ++int gsl_sf_gamma_e(const double x, gsl_sf_result * result); ++double gsl_sf_gamma(const double x); ++ ++ ++/* Regulated Gamma Function, x > 0 ++ * Gamma^*(x) = Gamma(x)/(Sqrt[2Pi] x^(x-1/2) exp(-x)) ++ * = (1 + 1/(12x) + ...), x->Inf ++ * A useful suggestion of Temme. ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gammastar_e(const double x, gsl_sf_result * result); ++double gsl_sf_gammastar(const double x); ++ ++ ++/* 1/Gamma(x) ++ * Uses real Lanczos method. ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EROUND ++ */ ++int gsl_sf_gammainv_e(const double x, gsl_sf_result * result); ++double gsl_sf_gammainv(const double x); ++ ++ ++/* Log[Gamma(z)] for z complex, z not a negative integer ++ * Uses complex Lanczos method. Note that the phase part (arg) ++ * is not well-determined when |z| is very large, due ++ * to inevitable roundoff in restricting to (-Pi,Pi]. ++ * This will raise the GSL_ELOSS exception when it occurs. ++ * The absolute value part (lnr), however, never suffers. ++ * ++ * Calculates: ++ * lnr = log|Gamma(z)| ++ * arg = arg(Gamma(z)) in (-Pi, Pi] ++ * ++ * exceptions: GSL_EDOM, GSL_ELOSS ++ */ ++int gsl_sf_lngamma_complex_e(double zr, double zi, gsl_sf_result * lnr, gsl_sf_result * arg); ++ ++ ++/* x^n / n! ++ * ++ * x >= 0.0, n >= 0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_taylorcoeff_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_taylorcoeff(const int n, const double x); ++ ++ ++/* n! ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_fact_e(const unsigned int n, gsl_sf_result * result); ++double gsl_sf_fact(const unsigned int n); ++ ++ ++/* n!! = n(n-2)(n-4) ... ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_doublefact_e(const unsigned int n, gsl_sf_result * result); ++double gsl_sf_doublefact(const unsigned int n); ++ ++ ++/* log(n!) ++ * Faster than ln(Gamma(n+1)) for n < 170; defers for larger n. ++ * ++ * exceptions: none ++ */ ++int gsl_sf_lnfact_e(const unsigned int n, gsl_sf_result * result); ++double gsl_sf_lnfact(const unsigned int n); ++ ++ ++/* log(n!!) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_lndoublefact_e(const unsigned int n, gsl_sf_result * result); ++double gsl_sf_lndoublefact(const unsigned int n); ++ ++ ++/* log(n choose m) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_lnchoose_e(unsigned int n, unsigned int m, gsl_sf_result * result); ++double gsl_sf_lnchoose(unsigned int n, unsigned int m); ++ ++ ++/* n choose m ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_choose_e(unsigned int n, unsigned int m, gsl_sf_result * result); ++double gsl_sf_choose(unsigned int n, unsigned int m); ++ ++ ++/* Logarithm of Pochhammer (Apell) symbol ++ * log( (a)_x ) ++ * where (a)_x := Gamma[a + x]/Gamma[a] ++ * ++ * a > 0, a+x > 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_lnpoch_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_lnpoch(const double a, const double x); ++ ++ ++/* Logarithm of Pochhammer (Apell) symbol, with sign information. ++ * result = log( |(a)_x| ) ++ * sgn = sgn( (a)_x ) ++ * where (a)_x := Gamma[a + x]/Gamma[a] ++ * ++ * a != neg integer, a+x != neg integer ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_lnpoch_sgn_e(const double a, const double x, gsl_sf_result * result, double * sgn); ++ ++ ++/* Pochhammer (Apell) symbol ++ * (a)_x := Gamma[a + x]/Gamma[x] ++ * ++ * a != neg integer, a+x != neg integer ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_poch_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_poch(const double a, const double x); ++ ++ ++/* Relative Pochhammer (Apell) symbol ++ * ((a,x) - 1)/x ++ * where (a,x) = (a)_x := Gamma[a + x]/Gamma[a] ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_pochrel_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_pochrel(const double a, const double x); ++ ++ ++/* Normalized Incomplete Gamma Function ++ * ++ * Q(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,x,Infinity} ] ++ * ++ * a >= 0, x >= 0 ++ * Q(a,0) := 1 ++ * Q(0,x) := 0, x != 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gamma_inc_Q_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_gamma_inc_Q(const double a, const double x); ++ ++ ++/* Complementary Normalized Incomplete Gamma Function ++ * ++ * P(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,0,x} ] ++ * ++ * a > 0, x >= 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gamma_inc_P_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_gamma_inc_P(const double a, const double x); ++ ++ ++/* Non-normalized Incomplete Gamma Function ++ * ++ * Gamma(a,x) := Integral[ t^(a-1) e^(-t), {t,x,Infinity} ] ++ * ++ * x >= 0.0 ++ * Gamma(a, 0) := Gamma(a) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_gamma_inc_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_gamma_inc(const double a, const double x); ++ ++ ++/* Logarithm of Beta Function ++ * Log[B(a,b)] ++ * ++ * a > 0, b > 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_lnbeta_e(const double a, const double b, gsl_sf_result * result); ++double gsl_sf_lnbeta(const double a, const double b); ++ ++int gsl_sf_lnbeta_sgn_e(const double x, const double y, gsl_sf_result * result, double * sgn); ++ ++ ++/* Beta Function ++ * B(a,b) ++ * ++ * a > 0, b > 0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_beta_e(const double a, const double b, gsl_sf_result * result); ++double gsl_sf_beta(const double a, const double b); ++ ++ ++/* Normalized Incomplete Beta Function ++ * B_x(a,b)/B(a,b) ++ * ++ * a > 0, b > 0, 0 <= x <= 1 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_beta_inc_e(const double a, const double b, const double x, gsl_sf_result * result); ++double gsl_sf_beta_inc(const double a, const double b, const double x); ++ ++ ++/* The maximum x such that gamma(x) is not ++ * considered an overflow. ++ */ ++#define GSL_SF_GAMMA_XMAX 171.0 ++ ++/* The maximum n such that gsl_sf_fact(n) does not give an overflow. */ ++#define GSL_SF_FACT_NMAX 170 ++ ++/* The maximum n such that gsl_sf_doublefact(n) does not give an overflow. */ ++#define GSL_SF_DOUBLEFACT_NMAX 297 ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_GAMMA_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_LONG_DOUBLE_H__ ++#define __GSL_VECTOR_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ long double *data; ++ gsl_block_long_double *block; ++ int owner; ++} ++gsl_vector_long_double; ++ ++typedef struct ++{ ++ gsl_vector_long_double vector; ++} _gsl_vector_long_double_view; ++ ++typedef _gsl_vector_long_double_view gsl_vector_long_double_view; ++ ++typedef struct ++{ ++ gsl_vector_long_double vector; ++} _gsl_vector_long_double_const_view; ++ ++typedef const _gsl_vector_long_double_const_view gsl_vector_long_double_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_long_double *gsl_vector_long_double_alloc (const size_t n); ++gsl_vector_long_double *gsl_vector_long_double_calloc (const size_t n); ++ ++gsl_vector_long_double *gsl_vector_long_double_alloc_from_block (gsl_block_long_double * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_long_double *gsl_vector_long_double_alloc_from_vector (gsl_vector_long_double * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_long_double_free (gsl_vector_long_double * v); ++ ++/* Views */ ++ ++_gsl_vector_long_double_view ++gsl_vector_long_double_view_array (long double *v, size_t n); ++ ++_gsl_vector_long_double_view ++gsl_vector_long_double_view_array_with_stride (long double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_long_double_const_view_array (const long double *v, size_t n); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_long_double_const_view_array_with_stride (const long double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_double_view ++gsl_vector_long_double_subvector (gsl_vector_long_double *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_long_double_view ++gsl_vector_long_double_subvector_with_stride (gsl_vector_long_double *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_long_double_const_subvector (const gsl_vector_long_double *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_long_double_const_subvector_with_stride (const gsl_vector_long_double *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_long_double_set_zero (gsl_vector_long_double * v); ++void gsl_vector_long_double_set_all (gsl_vector_long_double * v, long double x); ++int gsl_vector_long_double_set_basis (gsl_vector_long_double * v, size_t i); ++ ++int gsl_vector_long_double_fread (FILE * stream, gsl_vector_long_double * v); ++int gsl_vector_long_double_fwrite (FILE * stream, const gsl_vector_long_double * v); ++int gsl_vector_long_double_fscanf (FILE * stream, gsl_vector_long_double * v); ++int gsl_vector_long_double_fprintf (FILE * stream, const gsl_vector_long_double * v, ++ const char *format); ++ ++int gsl_vector_long_double_memcpy (gsl_vector_long_double * dest, const gsl_vector_long_double * src); ++ ++int gsl_vector_long_double_reverse (gsl_vector_long_double * v); ++ ++int gsl_vector_long_double_swap (gsl_vector_long_double * v, gsl_vector_long_double * w); ++int gsl_vector_long_double_swap_elements (gsl_vector_long_double * v, const size_t i, const size_t j); ++ ++long double gsl_vector_long_double_max (const gsl_vector_long_double * v); ++long double gsl_vector_long_double_min (const gsl_vector_long_double * v); ++void gsl_vector_long_double_minmax (const gsl_vector_long_double * v, long double * min_out, long double * max_out); ++ ++size_t gsl_vector_long_double_max_index (const gsl_vector_long_double * v); ++size_t gsl_vector_long_double_min_index (const gsl_vector_long_double * v); ++void gsl_vector_long_double_minmax_index (const gsl_vector_long_double * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_long_double_add (gsl_vector_long_double * a, const gsl_vector_long_double * b); ++int gsl_vector_long_double_sub (gsl_vector_long_double * a, const gsl_vector_long_double * b); ++int gsl_vector_long_double_mul (gsl_vector_long_double * a, const gsl_vector_long_double * b); ++int gsl_vector_long_double_div (gsl_vector_long_double * a, const gsl_vector_long_double * b); ++int gsl_vector_long_double_scale (gsl_vector_long_double * a, const double x); ++int gsl_vector_long_double_add_constant (gsl_vector_long_double * a, const double x); ++ ++int gsl_vector_long_double_equal (const gsl_vector_long_double * u, ++ const gsl_vector_long_double * v); ++ ++int gsl_vector_long_double_isnull (const gsl_vector_long_double * v); ++int gsl_vector_long_double_ispos (const gsl_vector_long_double * v); ++int gsl_vector_long_double_isneg (const gsl_vector_long_double * v); ++int gsl_vector_long_double_isnonneg (const gsl_vector_long_double * v); ++ ++INLINE_DECL long double gsl_vector_long_double_get (const gsl_vector_long_double * v, const size_t i); ++INLINE_DECL void gsl_vector_long_double_set (gsl_vector_long_double * v, const size_t i, long double x); ++INLINE_DECL long double * gsl_vector_long_double_ptr (gsl_vector_long_double * v, const size_t i); ++INLINE_DECL const long double * gsl_vector_long_double_const_ptr (const gsl_vector_long_double * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++long double ++gsl_vector_long_double_get (const gsl_vector_long_double * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_long_double_set (gsl_vector_long_double * v, const size_t i, long double x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++long double * ++gsl_vector_long_double_ptr (gsl_vector_long_double * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (long double *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const long double * ++gsl_vector_long_double_const_ptr (const gsl_vector_long_double * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const long double *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_LONG_DOUBLE_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_DOUBLE_H__ ++#define __GSL_PERMUTE_DOUBLE_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute (const size_t * p, double * data, const size_t stride, const size_t n); ++int gsl_permute_inverse (const size_t * p, double * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_LONG_DOUBLE_H__ ++#define __GSL_MATRIX_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ long double * data; ++ gsl_block_long_double * block; ++ int owner; ++} gsl_matrix_long_double; ++ ++typedef struct ++{ ++ gsl_matrix_long_double matrix; ++} _gsl_matrix_long_double_view; ++ ++typedef _gsl_matrix_long_double_view gsl_matrix_long_double_view; ++ ++typedef struct ++{ ++ gsl_matrix_long_double matrix; ++} _gsl_matrix_long_double_const_view; ++ ++typedef const _gsl_matrix_long_double_const_view gsl_matrix_long_double_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_long_double * ++gsl_matrix_long_double_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_long_double * ++gsl_matrix_long_double_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_long_double * ++gsl_matrix_long_double_alloc_from_block (gsl_block_long_double * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_long_double * ++gsl_matrix_long_double_alloc_from_matrix (gsl_matrix_long_double * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_long_double * ++gsl_vector_long_double_alloc_row_from_matrix (gsl_matrix_long_double * m, ++ const size_t i); ++ ++gsl_vector_long_double * ++gsl_vector_long_double_alloc_col_from_matrix (gsl_matrix_long_double * m, ++ const size_t j); ++ ++void gsl_matrix_long_double_free (gsl_matrix_long_double * m); ++ ++/* Views */ ++ ++_gsl_matrix_long_double_view ++gsl_matrix_long_double_submatrix (gsl_matrix_long_double * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_row (gsl_matrix_long_double * m, const size_t i); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_column (gsl_matrix_long_double * m, const size_t j); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_diagonal (gsl_matrix_long_double * m); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_subdiagonal (gsl_matrix_long_double * m, const size_t k); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_superdiagonal (gsl_matrix_long_double * m, const size_t k); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_subrow (gsl_matrix_long_double * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_long_double_view ++gsl_matrix_long_double_subcolumn (gsl_matrix_long_double * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_long_double_view ++gsl_matrix_long_double_view_array (long double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_double_view ++gsl_matrix_long_double_view_array_with_tda (long double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_long_double_view ++gsl_matrix_long_double_view_vector (gsl_vector_long_double * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_double_view ++gsl_matrix_long_double_view_vector_with_tda (gsl_vector_long_double * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_long_double_const_view ++gsl_matrix_long_double_const_submatrix (const gsl_matrix_long_double * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_row (const gsl_matrix_long_double * m, ++ const size_t i); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_column (const gsl_matrix_long_double * m, ++ const size_t j); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_diagonal (const gsl_matrix_long_double * m); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_subdiagonal (const gsl_matrix_long_double * m, ++ const size_t k); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_superdiagonal (const gsl_matrix_long_double * m, ++ const size_t k); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_subrow (const gsl_matrix_long_double * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_long_double_const_view ++gsl_matrix_long_double_const_subcolumn (const gsl_matrix_long_double * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_long_double_const_view ++gsl_matrix_long_double_const_view_array (const long double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_double_const_view ++gsl_matrix_long_double_const_view_array_with_tda (const long double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_long_double_const_view ++gsl_matrix_long_double_const_view_vector (const gsl_vector_long_double * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_double_const_view ++gsl_matrix_long_double_const_view_vector_with_tda (const gsl_vector_long_double * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_long_double_set_zero (gsl_matrix_long_double * m); ++void gsl_matrix_long_double_set_identity (gsl_matrix_long_double * m); ++void gsl_matrix_long_double_set_all (gsl_matrix_long_double * m, long double x); ++ ++int gsl_matrix_long_double_fread (FILE * stream, gsl_matrix_long_double * m) ; ++int gsl_matrix_long_double_fwrite (FILE * stream, const gsl_matrix_long_double * m) ; ++int gsl_matrix_long_double_fscanf (FILE * stream, gsl_matrix_long_double * m); ++int gsl_matrix_long_double_fprintf (FILE * stream, const gsl_matrix_long_double * m, const char * format); ++ ++int gsl_matrix_long_double_memcpy(gsl_matrix_long_double * dest, const gsl_matrix_long_double * src); ++int gsl_matrix_long_double_swap(gsl_matrix_long_double * m1, gsl_matrix_long_double * m2); ++ ++int gsl_matrix_long_double_swap_rows(gsl_matrix_long_double * m, const size_t i, const size_t j); ++int gsl_matrix_long_double_swap_columns(gsl_matrix_long_double * m, const size_t i, const size_t j); ++int gsl_matrix_long_double_swap_rowcol(gsl_matrix_long_double * m, const size_t i, const size_t j); ++int gsl_matrix_long_double_transpose (gsl_matrix_long_double * m); ++int gsl_matrix_long_double_transpose_memcpy (gsl_matrix_long_double * dest, const gsl_matrix_long_double * src); ++ ++long double gsl_matrix_long_double_max (const gsl_matrix_long_double * m); ++long double gsl_matrix_long_double_min (const gsl_matrix_long_double * m); ++void gsl_matrix_long_double_minmax (const gsl_matrix_long_double * m, long double * min_out, long double * max_out); ++ ++void gsl_matrix_long_double_max_index (const gsl_matrix_long_double * m, size_t * imax, size_t *jmax); ++void gsl_matrix_long_double_min_index (const gsl_matrix_long_double * m, size_t * imin, size_t *jmin); ++void gsl_matrix_long_double_minmax_index (const gsl_matrix_long_double * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_long_double_equal (const gsl_matrix_long_double * a, const gsl_matrix_long_double * b); ++ ++int gsl_matrix_long_double_isnull (const gsl_matrix_long_double * m); ++int gsl_matrix_long_double_ispos (const gsl_matrix_long_double * m); ++int gsl_matrix_long_double_isneg (const gsl_matrix_long_double * m); ++int gsl_matrix_long_double_isnonneg (const gsl_matrix_long_double * m); ++ ++int gsl_matrix_long_double_add (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); ++int gsl_matrix_long_double_sub (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); ++int gsl_matrix_long_double_mul_elements (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); ++int gsl_matrix_long_double_div_elements (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); ++int gsl_matrix_long_double_scale (gsl_matrix_long_double * a, const double x); ++int gsl_matrix_long_double_add_constant (gsl_matrix_long_double * a, const double x); ++int gsl_matrix_long_double_add_diagonal (gsl_matrix_long_double * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_long_double_get_row(gsl_vector_long_double * v, const gsl_matrix_long_double * m, const size_t i); ++int gsl_matrix_long_double_get_col(gsl_vector_long_double * v, const gsl_matrix_long_double * m, const size_t j); ++int gsl_matrix_long_double_set_row(gsl_matrix_long_double * m, const size_t i, const gsl_vector_long_double * v); ++int gsl_matrix_long_double_set_col(gsl_matrix_long_double * m, const size_t j, const gsl_vector_long_double * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL long double gsl_matrix_long_double_get(const gsl_matrix_long_double * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_long_double_set(gsl_matrix_long_double * m, const size_t i, const size_t j, const long double x); ++INLINE_DECL long double * gsl_matrix_long_double_ptr(gsl_matrix_long_double * m, const size_t i, const size_t j); ++INLINE_DECL const long double * gsl_matrix_long_double_const_ptr(const gsl_matrix_long_double * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++long double ++gsl_matrix_long_double_get(const gsl_matrix_long_double * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_long_double_set(gsl_matrix_long_double * m, const size_t i, const size_t j, const long double x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++long double * ++gsl_matrix_long_double_ptr(gsl_matrix_long_double * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (long double *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const long double * ++gsl_matrix_long_double_const_ptr(const gsl_matrix_long_double * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const long double *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h (revision 14078) +@@ -0,0 +1,99 @@ ++/* statistics/gsl_statistics_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_FLOAT_H__ ++#define __GSL_STATISTICS_FLOAT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_float_mean (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_variance (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_sd (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_variance_with_fixed_mean (const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_sd_with_fixed_mean (const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_tss (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_tss_m (const float data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_float_absdev (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_skew (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_kurtosis (const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_lag1_autocorrelation (const float data[], const size_t stride, const size_t n); ++ ++double gsl_stats_float_covariance (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n); ++double gsl_stats_float_correlation (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_float_variance_m (const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_sd_m (const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_absdev_m (const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_skew_m_sd (const float data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_float_kurtosis_m_sd (const float data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_float_lag1_autocorrelation_m (const float data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_float_covariance_m (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++/* DEFINED FOR FLOATING POINT TYPES ONLY */ ++ ++double gsl_stats_float_wmean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wvariance (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wsd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wvariance_with_fixed_mean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_wsd_with_fixed_mean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_float_wtss (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wtss_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_float_wabsdev (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wskew (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++double gsl_stats_float_wkurtosis (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); ++ ++double gsl_stats_float_wvariance_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_float_wsd_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_float_wabsdev_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_float_wskew_m_sd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++double gsl_stats_float_wkurtosis_m_sd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++ ++/* END OF FLOATING POINT TYPES */ ++ ++double gsl_stats_float_pvariance (const float data1[], const size_t stride1, const size_t n1, const float data2[], const size_t stride2, const size_t n2); ++double gsl_stats_float_ttest (const float data1[], const size_t stride1, const size_t n1, const float data2[], const size_t stride2, const size_t n2); ++ ++float gsl_stats_float_max (const float data[], const size_t stride, const size_t n); ++float gsl_stats_float_min (const float data[], const size_t stride, const size_t n); ++void gsl_stats_float_minmax (float * min, float * max, const float data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_float_max_index (const float data[], const size_t stride, const size_t n); ++size_t gsl_stats_float_min_index (const float data[], const size_t stride, const size_t n); ++void gsl_stats_float_minmax_index (size_t * min_index, size_t * max_index, const float data[], const size_t stride, const size_t n); ++ ++double gsl_stats_float_median_from_sorted_data (const float sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_float_quantile_from_sorted_data (const float sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_UINT_H__ ++#define __GSL_PERMUTE_UINT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_uint (const size_t * p, unsigned int * data, const size_t stride, const size_t n); ++int gsl_permute_uint_inverse (const size_t * p, unsigned int * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_DOUBLE_H__ ++#define __GSL_SORT_DOUBLE_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort (double * data, const size_t stride, const size_t n); ++void gsl_sort_index (size_t * p, const double * data, const size_t stride, const size_t n); ++ ++int gsl_sort_smallest (double * dest, const size_t k, const double * src, const size_t stride, const size_t n); ++int gsl_sort_smallest_index (size_t * p, const size_t k, const double * src, const size_t stride, const size_t n); ++ ++int gsl_sort_largest (double * dest, const size_t k, const double * src, const size_t stride, const size_t n); ++int gsl_sort_largest_index (size_t * p, const size_t k, const double * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h (revision 14078) +@@ -0,0 +1,99 @@ ++/* statistics/gsl_statistics_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_DOUBLE_H__ ++#define __GSL_STATISTICS_DOUBLE_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_mean (const double data[], const size_t stride, const size_t n); ++double gsl_stats_variance (const double data[], const size_t stride, const size_t n); ++double gsl_stats_sd (const double data[], const size_t stride, const size_t n); ++double gsl_stats_variance_with_fixed_mean (const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_sd_with_fixed_mean (const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_tss (const double data[], const size_t stride, const size_t n); ++double gsl_stats_tss_m (const double data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_absdev (const double data[], const size_t stride, const size_t n); ++double gsl_stats_skew (const double data[], const size_t stride, const size_t n); ++double gsl_stats_kurtosis (const double data[], const size_t stride, const size_t n); ++double gsl_stats_lag1_autocorrelation (const double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_covariance (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n); ++double gsl_stats_correlation (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_variance_m (const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_sd_m (const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_absdev_m (const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_skew_m_sd (const double data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_kurtosis_m_sd (const double data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_lag1_autocorrelation_m (const double data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_covariance_m (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++/* DEFINED FOR FLOATING POINT TYPES ONLY */ ++ ++double gsl_stats_wmean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wvariance (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wsd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wvariance_with_fixed_mean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_wsd_with_fixed_mean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_wtss (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wtss_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_wabsdev (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wskew (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++double gsl_stats_wkurtosis (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_wvariance_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_wsd_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_wabsdev_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_wskew_m_sd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++double gsl_stats_wkurtosis_m_sd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++ ++/* END OF FLOATING POINT TYPES */ ++ ++double gsl_stats_pvariance (const double data1[], const size_t stride1, const size_t n1, const double data2[], const size_t stride2, const size_t n2); ++double gsl_stats_ttest (const double data1[], const size_t stride1, const size_t n1, const double data2[], const size_t stride2, const size_t n2); ++ ++double gsl_stats_max (const double data[], const size_t stride, const size_t n); ++double gsl_stats_min (const double data[], const size_t stride, const size_t n); ++void gsl_stats_minmax (double * min, double * max, const double data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_max_index (const double data[], const size_t stride, const size_t n); ++size_t gsl_stats_min_index (const double data[], const size_t stride, const size_t n); ++void gsl_stats_minmax_index (size_t * min_index, size_t * max_index, const double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_median_from_sorted_data (const double sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_quantile_from_sorted_data (const double sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h (revision 14078) +@@ -0,0 +1,134 @@ ++/* specfunc/gsl_sf_exp.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_EXP_H__ ++#define __GSL_SF_EXP_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Provide an exp() function with GSL semantics, ++ * i.e. with proper error checking, etc. ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_e(const double x, gsl_sf_result * result); ++double gsl_sf_exp(const double x); ++ ++ ++/* Exp(x) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_e10_e(const double x, gsl_sf_result_e10 * result); ++ ++ ++/* Exponentiate and multiply by a given factor: y * Exp(x) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_mult_e(const double x, const double y, gsl_sf_result * result); ++double gsl_sf_exp_mult(const double x, const double y); ++ ++ ++/* Exponentiate and multiply by a given factor: y * Exp(x) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_mult_e10_e(const double x, const double y, gsl_sf_result_e10 * result); ++ ++ ++/* exp(x)-1 ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_expm1_e(const double x, gsl_sf_result * result); ++double gsl_sf_expm1(const double x); ++ ++ ++/* (exp(x)-1)/x = 1 + x/2 + x^2/(2*3) + x^3/(2*3*4) + ... ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_exprel_e(const double x, gsl_sf_result * result); ++double gsl_sf_exprel(const double x); ++ ++ ++/* 2(exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(3*4) + x^3/(3*4*5) + ... ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_exprel_2_e(double x, gsl_sf_result * result); ++double gsl_sf_exprel_2(const double x); ++ ++ ++/* Similarly for the N-th generalization of ++ * the above. The so-called N-relative exponential ++ * ++ * exprel_N(x) = N!/x^N (exp(x) - Sum[x^k/k!, {k,0,N-1}]) ++ * = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ... ++ * = 1F1(1,1+N,x) ++ */ ++int gsl_sf_exprel_n_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_exprel_n(const int n, const double x); ++ ++int gsl_sf_exprel_n_CF_e(const double n, const double x, gsl_sf_result * result); ++ ++ ++/* Exponentiate a quantity with an associated error. ++ */ ++int gsl_sf_exp_err_e(const double x, const double dx, gsl_sf_result * result); ++ ++/* Exponentiate a quantity with an associated error. ++ */ ++int gsl_sf_exp_err_e10_e(const double x, const double dx, gsl_sf_result_e10 * result); ++ ++ ++/* Exponentiate and multiply by a given factor: y * Exp(x), ++ * for quantities with associated errors. ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_mult_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result); ++ ++ ++/* Exponentiate and multiply by a given factor: y * Exp(x), ++ * for quantities with associated errors. ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_exp_mult_err_e10_e(const double x, const double dx, const double y, const double dy, gsl_sf_result_e10 * result); ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_EXP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h (revision 14078) +@@ -0,0 +1,154 @@ ++/* err/gsl_errno.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_ERRNO_H__ ++#define __GSL_ERRNO_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++enum { ++ GSL_SUCCESS = 0, ++ GSL_FAILURE = -1, ++ GSL_CONTINUE = -2, /* iteration has not converged */ ++ GSL_EDOM = 1, /* input domain error, e.g sqrt(-1) */ ++ GSL_ERANGE = 2, /* output range error, e.g. exp(1e100) */ ++ GSL_EFAULT = 3, /* invalid pointer */ ++ GSL_EINVAL = 4, /* invalid argument supplied by user */ ++ GSL_EFAILED = 5, /* generic failure */ ++ GSL_EFACTOR = 6, /* factorization failed */ ++ GSL_ESANITY = 7, /* sanity check failed - shouldn't happen */ ++ GSL_ENOMEM = 8, /* malloc failed */ ++ GSL_EBADFUNC = 9, /* problem with user-supplied function */ ++ GSL_ERUNAWAY = 10, /* iterative process is out of control */ ++ GSL_EMAXITER = 11, /* exceeded max number of iterations */ ++ GSL_EZERODIV = 12, /* tried to divide by zero */ ++ GSL_EBADTOL = 13, /* user specified an invalid tolerance */ ++ GSL_ETOL = 14, /* failed to reach the specified tolerance */ ++ GSL_EUNDRFLW = 15, /* underflow */ ++ GSL_EOVRFLW = 16, /* overflow */ ++ GSL_ELOSS = 17, /* loss of accuracy */ ++ GSL_EROUND = 18, /* failed because of roundoff error */ ++ GSL_EBADLEN = 19, /* matrix, vector lengths are not conformant */ ++ GSL_ENOTSQR = 20, /* matrix not square */ ++ GSL_ESING = 21, /* apparent singularity detected */ ++ GSL_EDIVERGE = 22, /* integral or series is divergent */ ++ GSL_EUNSUP = 23, /* requested feature is not supported by the hardware */ ++ GSL_EUNIMPL = 24, /* requested feature not (yet) implemented */ ++ GSL_ECACHE = 25, /* cache limit exceeded */ ++ GSL_ETABLE = 26, /* table limit exceeded */ ++ GSL_ENOPROG = 27, /* iteration is not making progress towards solution */ ++ GSL_ENOPROGJ = 28, /* jacobian evaluations are not improving the solution */ ++ GSL_ETOLF = 29, /* cannot reach the specified tolerance in F */ ++ GSL_ETOLX = 30, /* cannot reach the specified tolerance in X */ ++ GSL_ETOLG = 31, /* cannot reach the specified tolerance in gradient */ ++ GSL_EOF = 32 /* end of file */ ++} ; ++ ++void gsl_error (const char * reason, const char * file, int line, ++ int gsl_errno); ++ ++void gsl_stream_printf (const char *label, const char *file, ++ int line, const char *reason); ++ ++const char * gsl_strerror (const int gsl_errno); ++ ++typedef void gsl_error_handler_t (const char * reason, const char * file, ++ int line, int gsl_errno); ++ ++typedef void gsl_stream_handler_t (const char * label, const char * file, ++ int line, const char * reason); ++ ++gsl_error_handler_t * ++gsl_set_error_handler (gsl_error_handler_t * new_handler); ++ ++gsl_error_handler_t * ++gsl_set_error_handler_off (void); ++ ++gsl_stream_handler_t * ++gsl_set_stream_handler (gsl_stream_handler_t * new_handler); ++ ++FILE * gsl_set_stream (FILE * new_stream); ++ ++/* GSL_ERROR: call the error handler, and return the error code */ ++ ++#define GSL_ERROR(reason, gsl_errno) \ ++ do { \ ++ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ ++ return gsl_errno ; \ ++ } while (0) ++ ++/* GSL_ERROR_VAL: call the error handler, and return the given value */ ++ ++#define GSL_ERROR_VAL(reason, gsl_errno, value) \ ++ do { \ ++ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ ++ return value ; \ ++ } while (0) ++ ++/* GSL_ERROR_VOID: call the error handler, and then return ++ (for void functions which still need to generate an error) */ ++ ++#define GSL_ERROR_VOID(reason, gsl_errno) \ ++ do { \ ++ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ ++ return ; \ ++ } while (0) ++ ++/* GSL_ERROR_NULL suitable for out-of-memory conditions */ ++ ++#define GSL_ERROR_NULL(reason, gsl_errno) GSL_ERROR_VAL(reason, gsl_errno, 0) ++ ++/* Sometimes you have several status results returned from ++ * function calls and you want to combine them in some sensible ++ * way. You cannot produce a "total" status condition, but you can ++ * pick one from a set of conditions based on an implied hierarchy. ++ * ++ * In other words: ++ * you have: status_a, status_b, ... ++ * you want: status = (status_a if it is bad, or status_b if it is bad,...) ++ * ++ * In this example you consider status_a to be more important and ++ * it is checked first, followed by the others in the order specified. ++ * ++ * Here are some dumb macros to do this. ++ */ ++#define GSL_ERROR_SELECT_2(a,b) ((a) != GSL_SUCCESS ? (a) : ((b) != GSL_SUCCESS ? (b) : GSL_SUCCESS)) ++#define GSL_ERROR_SELECT_3(a,b,c) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_2(b,c)) ++#define GSL_ERROR_SELECT_4(a,b,c,d) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_3(b,c,d)) ++#define GSL_ERROR_SELECT_5(a,b,c,d,e) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_4(b,c,d,e)) ++ ++#define GSL_STATUS_UPDATE(sp, s) do { if ((s) != GSL_SUCCESS) *(sp) = (s);} while(0) ++ ++__END_DECLS ++ ++#endif /* __GSL_ERRNO_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_ULONG_H__ ++#define __GSL_PERMUTE_ULONG_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_ulong (const size_t * p, unsigned long * data, const size_t stride, const size_t n); ++int gsl_permute_ulong_inverse (const size_t * p, unsigned long * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h (revision 14078) +@@ -0,0 +1,17 @@ ++#ifndef __GSL_VECTOR_COMPLEX_H__ ++#define __GSL_VECTOR_COMPLEX_H__ ++ ++#define GSL_VECTOR_REAL(z, i) ((z)->data[2*(i)*(z)->stride]) ++#define GSL_VECTOR_IMAG(z, i) ((z)->data[2*(i)*(z)->stride + 1]) ++ ++#if GSL_RANGE_CHECK ++#define GSL_VECTOR_COMPLEX(zv, i) (((i) >= (zv)->size ? (gsl_error ("index out of range", __FILE__, __LINE__, GSL_EINVAL), 0):0 , *GSL_COMPLEX_AT((zv),(i)))) ++#else ++#define GSL_VECTOR_COMPLEX(zv, i) (*GSL_COMPLEX_AT((zv),(i))) ++#endif ++ ++#define GSL_COMPLEX_AT(zv,i) ((gsl_complex*)&((zv)->data[2*(i)*(zv)->stride])) ++#define GSL_COMPLEX_FLOAT_AT(zv,i) ((gsl_complex_float*)&((zv)->data[2*(i)*(zv)->stride])) ++#define GSL_COMPLEX_LONG_DOUBLE_AT(zv,i) ((gsl_complex_long_double*)&((zv)->data[2*(i)*(zv)->stride])) ++ ++#endif /* __GSL_VECTOR_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_FLOAT_H__ ++#define __GSL_MATRIX_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ float * data; ++ gsl_block_float * block; ++ int owner; ++} gsl_matrix_float; ++ ++typedef struct ++{ ++ gsl_matrix_float matrix; ++} _gsl_matrix_float_view; ++ ++typedef _gsl_matrix_float_view gsl_matrix_float_view; ++ ++typedef struct ++{ ++ gsl_matrix_float matrix; ++} _gsl_matrix_float_const_view; ++ ++typedef const _gsl_matrix_float_const_view gsl_matrix_float_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_float * ++gsl_matrix_float_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_float * ++gsl_matrix_float_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_float * ++gsl_matrix_float_alloc_from_block (gsl_block_float * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_float * ++gsl_matrix_float_alloc_from_matrix (gsl_matrix_float * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_float * ++gsl_vector_float_alloc_row_from_matrix (gsl_matrix_float * m, ++ const size_t i); ++ ++gsl_vector_float * ++gsl_vector_float_alloc_col_from_matrix (gsl_matrix_float * m, ++ const size_t j); ++ ++void gsl_matrix_float_free (gsl_matrix_float * m); ++ ++/* Views */ ++ ++_gsl_matrix_float_view ++gsl_matrix_float_submatrix (gsl_matrix_float * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_float_view ++gsl_matrix_float_row (gsl_matrix_float * m, const size_t i); ++ ++_gsl_vector_float_view ++gsl_matrix_float_column (gsl_matrix_float * m, const size_t j); ++ ++_gsl_vector_float_view ++gsl_matrix_float_diagonal (gsl_matrix_float * m); ++ ++_gsl_vector_float_view ++gsl_matrix_float_subdiagonal (gsl_matrix_float * m, const size_t k); ++ ++_gsl_vector_float_view ++gsl_matrix_float_superdiagonal (gsl_matrix_float * m, const size_t k); ++ ++_gsl_vector_float_view ++gsl_matrix_float_subrow (gsl_matrix_float * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_float_view ++gsl_matrix_float_subcolumn (gsl_matrix_float * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_float_view ++gsl_matrix_float_view_array (float * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_float_view ++gsl_matrix_float_view_array_with_tda (float * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_float_view ++gsl_matrix_float_view_vector (gsl_vector_float * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_float_view ++gsl_matrix_float_view_vector_with_tda (gsl_vector_float * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_float_const_view ++gsl_matrix_float_const_submatrix (const gsl_matrix_float * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_row (const gsl_matrix_float * m, ++ const size_t i); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_column (const gsl_matrix_float * m, ++ const size_t j); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_diagonal (const gsl_matrix_float * m); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_subdiagonal (const gsl_matrix_float * m, ++ const size_t k); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_superdiagonal (const gsl_matrix_float * m, ++ const size_t k); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_subrow (const gsl_matrix_float * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_float_const_view ++gsl_matrix_float_const_subcolumn (const gsl_matrix_float * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_float_const_view ++gsl_matrix_float_const_view_array (const float * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_float_const_view ++gsl_matrix_float_const_view_array_with_tda (const float * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_float_const_view ++gsl_matrix_float_const_view_vector (const gsl_vector_float * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_float_const_view ++gsl_matrix_float_const_view_vector_with_tda (const gsl_vector_float * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_float_set_zero (gsl_matrix_float * m); ++void gsl_matrix_float_set_identity (gsl_matrix_float * m); ++void gsl_matrix_float_set_all (gsl_matrix_float * m, float x); ++ ++int gsl_matrix_float_fread (FILE * stream, gsl_matrix_float * m) ; ++int gsl_matrix_float_fwrite (FILE * stream, const gsl_matrix_float * m) ; ++int gsl_matrix_float_fscanf (FILE * stream, gsl_matrix_float * m); ++int gsl_matrix_float_fprintf (FILE * stream, const gsl_matrix_float * m, const char * format); ++ ++int gsl_matrix_float_memcpy(gsl_matrix_float * dest, const gsl_matrix_float * src); ++int gsl_matrix_float_swap(gsl_matrix_float * m1, gsl_matrix_float * m2); ++ ++int gsl_matrix_float_swap_rows(gsl_matrix_float * m, const size_t i, const size_t j); ++int gsl_matrix_float_swap_columns(gsl_matrix_float * m, const size_t i, const size_t j); ++int gsl_matrix_float_swap_rowcol(gsl_matrix_float * m, const size_t i, const size_t j); ++int gsl_matrix_float_transpose (gsl_matrix_float * m); ++int gsl_matrix_float_transpose_memcpy (gsl_matrix_float * dest, const gsl_matrix_float * src); ++ ++float gsl_matrix_float_max (const gsl_matrix_float * m); ++float gsl_matrix_float_min (const gsl_matrix_float * m); ++void gsl_matrix_float_minmax (const gsl_matrix_float * m, float * min_out, float * max_out); ++ ++void gsl_matrix_float_max_index (const gsl_matrix_float * m, size_t * imax, size_t *jmax); ++void gsl_matrix_float_min_index (const gsl_matrix_float * m, size_t * imin, size_t *jmin); ++void gsl_matrix_float_minmax_index (const gsl_matrix_float * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_float_equal (const gsl_matrix_float * a, const gsl_matrix_float * b); ++ ++int gsl_matrix_float_isnull (const gsl_matrix_float * m); ++int gsl_matrix_float_ispos (const gsl_matrix_float * m); ++int gsl_matrix_float_isneg (const gsl_matrix_float * m); ++int gsl_matrix_float_isnonneg (const gsl_matrix_float * m); ++ ++int gsl_matrix_float_add (gsl_matrix_float * a, const gsl_matrix_float * b); ++int gsl_matrix_float_sub (gsl_matrix_float * a, const gsl_matrix_float * b); ++int gsl_matrix_float_mul_elements (gsl_matrix_float * a, const gsl_matrix_float * b); ++int gsl_matrix_float_div_elements (gsl_matrix_float * a, const gsl_matrix_float * b); ++int gsl_matrix_float_scale (gsl_matrix_float * a, const double x); ++int gsl_matrix_float_add_constant (gsl_matrix_float * a, const double x); ++int gsl_matrix_float_add_diagonal (gsl_matrix_float * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_float_get_row(gsl_vector_float * v, const gsl_matrix_float * m, const size_t i); ++int gsl_matrix_float_get_col(gsl_vector_float * v, const gsl_matrix_float * m, const size_t j); ++int gsl_matrix_float_set_row(gsl_matrix_float * m, const size_t i, const gsl_vector_float * v); ++int gsl_matrix_float_set_col(gsl_matrix_float * m, const size_t j, const gsl_vector_float * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL float gsl_matrix_float_get(const gsl_matrix_float * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_float_set(gsl_matrix_float * m, const size_t i, const size_t j, const float x); ++INLINE_DECL float * gsl_matrix_float_ptr(gsl_matrix_float * m, const size_t i, const size_t j); ++INLINE_DECL const float * gsl_matrix_float_const_ptr(const gsl_matrix_float * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++float ++gsl_matrix_float_get(const gsl_matrix_float * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_float_set(gsl_matrix_float * m, const size_t i, const size_t j, const float x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++float * ++gsl_matrix_float_ptr(gsl_matrix_float * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (float *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const float * ++gsl_matrix_float_const_ptr(const gsl_matrix_float * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const float *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h (revision 14078) +@@ -0,0 +1,164 @@ ++/* gsl_math.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATH_H__ ++#define __GSL_MATH_H__ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#ifndef M_E ++#define M_E 2.71828182845904523536028747135 /* e */ ++#endif ++ ++#ifndef M_LOG2E ++#define M_LOG2E 1.44269504088896340735992468100 /* log_2 (e) */ ++#endif ++ ++#ifndef M_LOG10E ++#define M_LOG10E 0.43429448190325182765112891892 /* log_10 (e) */ ++#endif ++ ++#ifndef M_SQRT2 ++#define M_SQRT2 1.41421356237309504880168872421 /* sqrt(2) */ ++#endif ++ ++#ifndef M_SQRT1_2 ++#define M_SQRT1_2 0.70710678118654752440084436210 /* sqrt(1/2) */ ++#endif ++ ++ ++#ifndef M_SQRT3 ++#define M_SQRT3 1.73205080756887729352744634151 /* sqrt(3) */ ++#endif ++ ++#ifndef M_PI ++#define M_PI 3.14159265358979323846264338328 /* pi */ ++#endif ++ ++#ifndef M_PI_2 ++#define M_PI_2 1.57079632679489661923132169164 /* pi/2 */ ++#endif ++ ++#ifndef M_PI_4 ++#define M_PI_4 0.78539816339744830961566084582 /* pi/4 */ ++#endif ++ ++#ifndef M_SQRTPI ++#define M_SQRTPI 1.77245385090551602729816748334 /* sqrt(pi) */ ++#endif ++ ++#ifndef M_2_SQRTPI ++#define M_2_SQRTPI 1.12837916709551257389615890312 /* 2/sqrt(pi) */ ++#endif ++ ++#ifndef M_1_PI ++#define M_1_PI 0.31830988618379067153776752675 /* 1/pi */ ++#endif ++ ++#ifndef M_2_PI ++#define M_2_PI 0.63661977236758134307553505349 /* 2/pi */ ++#endif ++ ++#ifndef M_LN10 ++#define M_LN10 2.30258509299404568401799145468 /* ln(10) */ ++#endif ++ ++#ifndef M_LN2 ++#define M_LN2 0.69314718055994530941723212146 /* ln(2) */ ++#endif ++ ++#ifndef M_LNPI ++#define M_LNPI 1.14472988584940017414342735135 /* ln(pi) */ ++#endif ++ ++#ifndef M_EULER ++#define M_EULER 0.57721566490153286060651209008 /* Euler constant */ ++#endif ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* other needlessly compulsive abstractions */ ++ ++#define GSL_IS_ODD(n) ((n) & 1) ++#define GSL_IS_EVEN(n) (!(GSL_IS_ODD(n))) ++#define GSL_SIGN(x) ((x) >= 0.0 ? 1 : -1) ++ ++/* Return nonzero if x is a real number, i.e. non NaN or infinite. */ ++#define GSL_IS_REAL(x) (gsl_finite(x)) ++ ++/* Definition of an arbitrary function with parameters */ ++ ++struct gsl_function_struct ++{ ++ double (* function) (double x, void * params); ++ void * params; ++}; ++ ++typedef struct gsl_function_struct gsl_function ; ++ ++#define GSL_FN_EVAL(F,x) (*((F)->function))(x,(F)->params) ++ ++/* Definition of an arbitrary function returning two values, r1, r2 */ ++ ++struct gsl_function_fdf_struct ++{ ++ double (* f) (double x, void * params); ++ double (* df) (double x, void * params); ++ void (* fdf) (double x, void * params, double * f, double * df); ++ void * params; ++}; ++ ++typedef struct gsl_function_fdf_struct gsl_function_fdf ; ++ ++#define GSL_FN_FDF_EVAL_F(FDF,x) (*((FDF)->f))(x,(FDF)->params) ++#define GSL_FN_FDF_EVAL_DF(FDF,x) (*((FDF)->df))(x,(FDF)->params) ++#define GSL_FN_FDF_EVAL_F_DF(FDF,x,y,dy) (*((FDF)->fdf))(x,(FDF)->params,(y),(dy)) ++ ++ ++/* Definition of an arbitrary vector-valued function with parameters */ ++ ++struct gsl_function_vec_struct ++{ ++ int (* function) (double x, double y[], void * params); ++ void * params; ++}; ++ ++typedef struct gsl_function_vec_struct gsl_function_vec ; ++ ++#define GSL_FN_VEC_EVAL(F,x,y) (*((F)->function))(x,y,(F)->params) ++ ++__END_DECLS ++ ++#endif /* __GSL_MATH_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h (revision 14078) +@@ -0,0 +1,55 @@ ++/* fft/gsl_dft_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_DFT_COMPLEX_FLOAT_H__ ++#define __GSL_DFT_COMPLEX_FLOAT_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_dft_complex_float_forward (const float data[], const size_t stride, const size_t n, ++ float result[]); ++ ++int gsl_dft_complex_float_backward (const float data[], const size_t stride, const size_t n, ++ float result[]); ++ ++int gsl_dft_complex_float_inverse (const float data[], const size_t stride, const size_t n, ++ float result[]); ++ ++int gsl_dft_complex_float_transform (const float data[], const size_t stride, const size_t n, ++ float result[], const gsl_fft_direction sign); ++ ++__END_DECLS ++ ++#endif /* __GSL_DFT_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h (revision 14078) +@@ -0,0 +1,112 @@ ++/* specfunc/gsl_sf_zeta.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_ZETA_H__ ++#define __GSL_SF_ZETA_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Riemann Zeta Function ++ * zeta(n) = Sum[ k^(-n), {k,1,Infinity} ] ++ * ++ * n=integer, n != 1 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_zeta_int_e(const int n, gsl_sf_result * result); ++double gsl_sf_zeta_int(const int n); ++ ++ ++/* Riemann Zeta Function ++ * zeta(x) = Sum[ k^(-s), {k,1,Infinity} ], s != 1.0 ++ * ++ * s != 1.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_zeta_e(const double s, gsl_sf_result * result); ++double gsl_sf_zeta(const double s); ++ ++ ++/* Riemann Zeta Function minus 1 ++ * useful for evaluating the fractional part ++ * of Riemann zeta for large argument ++ * ++ * s != 1.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_zetam1_e(const double s, gsl_sf_result * result); ++double gsl_sf_zetam1(const double s); ++ ++ ++/* Riemann Zeta Function minus 1 for integer arg ++ * useful for evaluating the fractional part ++ * of Riemann zeta for large argument ++ * ++ * s != 1.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_zetam1_int_e(const int s, gsl_sf_result * result); ++double gsl_sf_zetam1_int(const int s); ++ ++ ++/* Hurwitz Zeta Function ++ * zeta(s,q) = Sum[ (k+q)^(-s), {k,0,Infinity} ] ++ * ++ * s > 1.0, q > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_hzeta_e(const double s, const double q, gsl_sf_result * result); ++double gsl_sf_hzeta(const double s, const double q); ++ ++ ++/* Eta Function ++ * eta(n) = (1-2^(1-n)) zeta(n) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_eta_int_e(int n, gsl_sf_result * result); ++double gsl_sf_eta_int(const int n); ++ ++ ++/* Eta Function ++ * eta(s) = (1-2^(1-s)) zeta(s) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_eta_e(const double s, gsl_sf_result * result); ++double gsl_sf_eta(const double s); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_ZETA_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h (revision 14078) +@@ -0,0 +1,107 @@ ++/* wavelet/gsl_wavelet.h ++ * ++ * Copyright (C) 2004 Ivo Alxneit ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_WAVELET2D_H__ ++#define __GSL_WAVELET2D_H__ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_wavelet2d_transform (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_direction dir, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet2d_transform_forward (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet2d_transform_inverse (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet2d_nstransform (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_direction dir, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet2d_nstransform_forward (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet2d_nstransform_inverse (const gsl_wavelet * w, ++ double *data, ++ size_t tda, size_t size1, size_t size2, ++ gsl_wavelet_workspace * work); ++ ++int ++gsl_wavelet2d_transform_matrix (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_direction dir, ++ gsl_wavelet_workspace * work); ++ ++int ++gsl_wavelet2d_transform_matrix_forward (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_workspace * work); ++ ++int ++gsl_wavelet2d_transform_matrix_inverse (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_workspace * work); ++ ++ ++int ++gsl_wavelet2d_nstransform_matrix (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_direction dir, ++ gsl_wavelet_workspace * work); ++ ++int ++gsl_wavelet2d_nstransform_matrix_forward (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_workspace * work); ++ ++int ++gsl_wavelet2d_nstransform_matrix_inverse (const gsl_wavelet * w, ++ gsl_matrix * a, ++ gsl_wavelet_workspace * work); ++ ++__END_DECLS ++ ++#endif /* __GSL_WAVELET2D_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h (revision 14078) +@@ -0,0 +1,134 @@ ++/* histogram/gsl_histogram.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_HISTOGRAM_H__ ++#define __GSL_HISTOGRAM_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ size_t n ; ++ double * range ; ++ double * bin ; ++} gsl_histogram ; ++ ++typedef struct { ++ size_t n ; ++ double * range ; ++ double * sum ; ++} gsl_histogram_pdf ; ++ ++gsl_histogram * gsl_histogram_alloc (size_t n); ++ ++gsl_histogram * gsl_histogram_calloc (size_t n); ++gsl_histogram * gsl_histogram_calloc_uniform (const size_t n, const double xmin, const double xmax); ++void gsl_histogram_free (gsl_histogram * h); ++int gsl_histogram_increment (gsl_histogram * h, double x); ++int gsl_histogram_accumulate (gsl_histogram * h, double x, double weight); ++int gsl_histogram_find (const gsl_histogram * h, ++ const double x, size_t * i); ++ ++double gsl_histogram_get (const gsl_histogram * h, size_t i); ++int gsl_histogram_get_range (const gsl_histogram * h, size_t i, ++ double * lower, double * upper); ++ ++double gsl_histogram_max (const gsl_histogram * h); ++double gsl_histogram_min (const gsl_histogram * h); ++size_t gsl_histogram_bins (const gsl_histogram * h); ++ ++void gsl_histogram_reset (gsl_histogram * h); ++ ++gsl_histogram * gsl_histogram_calloc_range(size_t n, double * range); ++ ++int ++gsl_histogram_set_ranges (gsl_histogram * h, const double range[], size_t size); ++int ++gsl_histogram_set_ranges_uniform (gsl_histogram * h, double xmin, double xmax); ++ ++ ++ ++int ++gsl_histogram_memcpy(gsl_histogram * dest, const gsl_histogram * source); ++ ++gsl_histogram * ++gsl_histogram_clone(const gsl_histogram * source); ++ ++double gsl_histogram_max_val (const gsl_histogram * h); ++ ++size_t gsl_histogram_max_bin (const gsl_histogram * h); ++ ++double gsl_histogram_min_val (const gsl_histogram * h); ++ ++size_t gsl_histogram_min_bin (const gsl_histogram * h); ++ ++int ++gsl_histogram_equal_bins_p(const gsl_histogram *h1, const gsl_histogram *h2); ++ ++int ++gsl_histogram_add(gsl_histogram *h1, const gsl_histogram *h2); ++ ++int ++gsl_histogram_sub(gsl_histogram *h1, const gsl_histogram *h2); ++ ++int ++gsl_histogram_mul(gsl_histogram *h1, const gsl_histogram *h2); ++ ++int ++gsl_histogram_div(gsl_histogram *h1, const gsl_histogram *h2); ++ ++int ++gsl_histogram_scale(gsl_histogram *h, double scale); ++ ++int ++gsl_histogram_shift (gsl_histogram * h, double shift); ++ ++ ++double gsl_histogram_sigma (const gsl_histogram * h); ++ ++double gsl_histogram_mean (const gsl_histogram * h); ++ ++double gsl_histogram_sum (const gsl_histogram * h); ++ ++int gsl_histogram_fwrite (FILE * stream, const gsl_histogram * h) ; ++int gsl_histogram_fread (FILE * stream, gsl_histogram * h); ++int gsl_histogram_fprintf (FILE * stream, const gsl_histogram * h, ++ const char * range_format, const char * bin_format); ++int gsl_histogram_fscanf (FILE * stream, gsl_histogram * h); ++ ++gsl_histogram_pdf * gsl_histogram_pdf_alloc (const size_t n); ++int gsl_histogram_pdf_init (gsl_histogram_pdf * p, const gsl_histogram * h); ++void gsl_histogram_pdf_free (gsl_histogram_pdf * p); ++double gsl_histogram_pdf_sample (const gsl_histogram_pdf * p, double r); ++ ++__END_DECLS ++ ++#endif /* __GSL_HISTOGRAM_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_CHAR_H__ ++#define __GSL_VECTOR_CHAR_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ char *data; ++ gsl_block_char *block; ++ int owner; ++} ++gsl_vector_char; ++ ++typedef struct ++{ ++ gsl_vector_char vector; ++} _gsl_vector_char_view; ++ ++typedef _gsl_vector_char_view gsl_vector_char_view; ++ ++typedef struct ++{ ++ gsl_vector_char vector; ++} _gsl_vector_char_const_view; ++ ++typedef const _gsl_vector_char_const_view gsl_vector_char_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_char *gsl_vector_char_alloc (const size_t n); ++gsl_vector_char *gsl_vector_char_calloc (const size_t n); ++ ++gsl_vector_char *gsl_vector_char_alloc_from_block (gsl_block_char * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_char *gsl_vector_char_alloc_from_vector (gsl_vector_char * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_char_free (gsl_vector_char * v); ++ ++/* Views */ ++ ++_gsl_vector_char_view ++gsl_vector_char_view_array (char *v, size_t n); ++ ++_gsl_vector_char_view ++gsl_vector_char_view_array_with_stride (char *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_char_const_view ++gsl_vector_char_const_view_array (const char *v, size_t n); ++ ++_gsl_vector_char_const_view ++gsl_vector_char_const_view_array_with_stride (const char *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_char_view ++gsl_vector_char_subvector (gsl_vector_char *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_char_view ++gsl_vector_char_subvector_with_stride (gsl_vector_char *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_char_const_view ++gsl_vector_char_const_subvector (const gsl_vector_char *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_char_const_view ++gsl_vector_char_const_subvector_with_stride (const gsl_vector_char *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_char_set_zero (gsl_vector_char * v); ++void gsl_vector_char_set_all (gsl_vector_char * v, char x); ++int gsl_vector_char_set_basis (gsl_vector_char * v, size_t i); ++ ++int gsl_vector_char_fread (FILE * stream, gsl_vector_char * v); ++int gsl_vector_char_fwrite (FILE * stream, const gsl_vector_char * v); ++int gsl_vector_char_fscanf (FILE * stream, gsl_vector_char * v); ++int gsl_vector_char_fprintf (FILE * stream, const gsl_vector_char * v, ++ const char *format); ++ ++int gsl_vector_char_memcpy (gsl_vector_char * dest, const gsl_vector_char * src); ++ ++int gsl_vector_char_reverse (gsl_vector_char * v); ++ ++int gsl_vector_char_swap (gsl_vector_char * v, gsl_vector_char * w); ++int gsl_vector_char_swap_elements (gsl_vector_char * v, const size_t i, const size_t j); ++ ++char gsl_vector_char_max (const gsl_vector_char * v); ++char gsl_vector_char_min (const gsl_vector_char * v); ++void gsl_vector_char_minmax (const gsl_vector_char * v, char * min_out, char * max_out); ++ ++size_t gsl_vector_char_max_index (const gsl_vector_char * v); ++size_t gsl_vector_char_min_index (const gsl_vector_char * v); ++void gsl_vector_char_minmax_index (const gsl_vector_char * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_char_add (gsl_vector_char * a, const gsl_vector_char * b); ++int gsl_vector_char_sub (gsl_vector_char * a, const gsl_vector_char * b); ++int gsl_vector_char_mul (gsl_vector_char * a, const gsl_vector_char * b); ++int gsl_vector_char_div (gsl_vector_char * a, const gsl_vector_char * b); ++int gsl_vector_char_scale (gsl_vector_char * a, const double x); ++int gsl_vector_char_add_constant (gsl_vector_char * a, const double x); ++ ++int gsl_vector_char_equal (const gsl_vector_char * u, ++ const gsl_vector_char * v); ++ ++int gsl_vector_char_isnull (const gsl_vector_char * v); ++int gsl_vector_char_ispos (const gsl_vector_char * v); ++int gsl_vector_char_isneg (const gsl_vector_char * v); ++int gsl_vector_char_isnonneg (const gsl_vector_char * v); ++ ++INLINE_DECL char gsl_vector_char_get (const gsl_vector_char * v, const size_t i); ++INLINE_DECL void gsl_vector_char_set (gsl_vector_char * v, const size_t i, char x); ++INLINE_DECL char * gsl_vector_char_ptr (gsl_vector_char * v, const size_t i); ++INLINE_DECL const char * gsl_vector_char_const_ptr (const gsl_vector_char * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++char ++gsl_vector_char_get (const gsl_vector_char * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_char_set (gsl_vector_char * v, const size_t i, char x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++char * ++gsl_vector_char_ptr (gsl_vector_char * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (char *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const char * ++gsl_vector_char_const_ptr (const gsl_vector_char * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const char *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_CHAR_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_LONG_H__ ++#define __GSL_PERMUTE_LONG_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_long (const size_t * p, long * data, const size_t stride, const size_t n); ++int gsl_permute_long_inverse (const size_t * p, long * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_CHAR_H__ ++#define __GSL_PERMUTE_VECTOR_CHAR_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_char (const gsl_permutation * p, gsl_vector_char * v); ++int gsl_permute_vector_char_inverse (const gsl_permutation * p, gsl_vector_char * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h (revision 14078) +@@ -0,0 +1,25 @@ ++#ifndef __GSL_VECTOR_H__ ++#define __GSL_VECTOR_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++ ++#endif /* __GSL_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_complex_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_COMPLEX_DOUBLE_H__ ++#define __GSL_PERMUTE_COMPLEX_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_complex (const size_t * p, double * data, const size_t stride, const size_t n); ++int gsl_permute_complex_inverse (const size_t * p, double * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_DOUBLE_H__ ++#define __GSL_SORT_VECTOR_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector (gsl_vector * v); ++int gsl_sort_vector_index (gsl_permutation * p, const gsl_vector * v); ++ ++int gsl_sort_vector_smallest (double * dest, const size_t k, const gsl_vector * v); ++int gsl_sort_vector_largest (double * dest, const size_t k, const gsl_vector * v); ++ ++int gsl_sort_vector_smallest_index (size_t * p, const size_t k, const gsl_vector * v); ++int gsl_sort_vector_largest_index (size_t * p, const size_t k, const gsl_vector * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h (revision 14078) +@@ -0,0 +1,25 @@ ++#ifndef __GSL_MATRIX_H__ ++#define __GSL_MATRIX_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++ ++#endif /* __GSL_MATRIX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h (revision 14078) +@@ -0,0 +1,104 @@ ++/* Author: B. Gough and G. Jungman */ ++#ifndef __GSL_MACHINE_H__ ++#define __GSL_MACHINE_H__ ++ ++#include ++#include ++ ++/* magic constants; mostly for the benefit of the implementation */ ++ ++/* -*-MACHINE CONSTANTS-*- ++ * ++ * PLATFORM: Whiz-O-Matic 9000 ++ * FP_PLATFORM: IEEE-Virtual ++ * HOSTNAME: nnn.lanl.gov ++ * DATE: Fri Nov 20 17:53:26 MST 1998 ++ */ ++#define GSL_DBL_EPSILON 2.2204460492503131e-16 ++#define GSL_SQRT_DBL_EPSILON 1.4901161193847656e-08 ++#define GSL_ROOT3_DBL_EPSILON 6.0554544523933429e-06 ++#define GSL_ROOT4_DBL_EPSILON 1.2207031250000000e-04 ++#define GSL_ROOT5_DBL_EPSILON 7.4009597974140505e-04 ++#define GSL_ROOT6_DBL_EPSILON 2.4607833005759251e-03 ++#define GSL_LOG_DBL_EPSILON (-3.6043653389117154e+01) ++ ++#define GSL_DBL_MIN 2.2250738585072014e-308 ++#define GSL_SQRT_DBL_MIN 1.4916681462400413e-154 ++#define GSL_ROOT3_DBL_MIN 2.8126442852362996e-103 ++#define GSL_ROOT4_DBL_MIN 1.2213386697554620e-77 ++#define GSL_ROOT5_DBL_MIN 2.9476022969691763e-62 ++#define GSL_ROOT6_DBL_MIN 5.3034368905798218e-52 ++#define GSL_LOG_DBL_MIN (-7.0839641853226408e+02) ++ ++#define GSL_DBL_MAX 1.7976931348623157e+308 ++#define GSL_SQRT_DBL_MAX 1.3407807929942596e+154 ++#define GSL_ROOT3_DBL_MAX 5.6438030941222897e+102 ++#define GSL_ROOT4_DBL_MAX 1.1579208923731620e+77 ++#define GSL_ROOT5_DBL_MAX 4.4765466227572707e+61 ++#define GSL_ROOT6_DBL_MAX 2.3756689782295612e+51 ++#define GSL_LOG_DBL_MAX 7.0978271289338397e+02 ++ ++#define GSL_FLT_EPSILON 1.1920928955078125e-07 ++#define GSL_SQRT_FLT_EPSILON 3.4526698300124393e-04 ++#define GSL_ROOT3_FLT_EPSILON 4.9215666011518501e-03 ++#define GSL_ROOT4_FLT_EPSILON 1.8581361171917516e-02 ++#define GSL_ROOT5_FLT_EPSILON 4.1234622211652937e-02 ++#define GSL_ROOT6_FLT_EPSILON 7.0153878019335827e-02 ++#define GSL_LOG_FLT_EPSILON (-1.5942385152878742e+01) ++ ++#define GSL_FLT_MIN 1.1754943508222875e-38 ++#define GSL_SQRT_FLT_MIN 1.0842021724855044e-19 ++#define GSL_ROOT3_FLT_MIN 2.2737367544323241e-13 ++#define GSL_ROOT4_FLT_MIN 3.2927225399135965e-10 ++#define GSL_ROOT5_FLT_MIN 2.5944428542140822e-08 ++#define GSL_ROOT6_FLT_MIN 4.7683715820312542e-07 ++#define GSL_LOG_FLT_MIN (-8.7336544750553102e+01) ++ ++#define GSL_FLT_MAX 3.4028234663852886e+38 ++#define GSL_SQRT_FLT_MAX 1.8446743523953730e+19 ++#define GSL_ROOT3_FLT_MAX 6.9814635196223242e+12 ++#define GSL_ROOT4_FLT_MAX 4.2949672319999986e+09 ++#define GSL_ROOT5_FLT_MAX 5.0859007855960041e+07 ++#define GSL_ROOT6_FLT_MAX 2.6422459233807749e+06 ++#define GSL_LOG_FLT_MAX 8.8722839052068352e+01 ++ ++#define GSL_SFLT_EPSILON 4.8828125000000000e-04 ++#define GSL_SQRT_SFLT_EPSILON 2.2097086912079612e-02 ++#define GSL_ROOT3_SFLT_EPSILON 7.8745065618429588e-02 ++#define GSL_ROOT4_SFLT_EPSILON 1.4865088937534013e-01 ++#define GSL_ROOT5_SFLT_EPSILON 2.1763764082403100e-01 ++#define GSL_ROOT6_SFLT_EPSILON 2.8061551207734325e-01 ++#define GSL_LOG_SFLT_EPSILON (-7.6246189861593985e+00) ++ ++/* !MACHINE CONSTANTS! */ ++ ++ ++/* a little internal backwards compatibility */ ++#define GSL_MACH_EPS GSL_DBL_EPSILON ++ ++ ++ ++/* Here are the constants related to or derived from ++ * machine constants. These are not to be confused with ++ * the constants that define various precision levels ++ * for the precision/error system. ++ * ++ * This information is determined at configure time ++ * and is platform dependent. Edit at your own risk. ++ * ++ * PLATFORM: WHIZ-O-MATIC ++ * CONFIG-DATE: Thu Nov 19 19:27:18 MST 1998 ++ * CONFIG-HOST: nnn.lanl.gov ++ */ ++ ++/* machine precision constants */ ++/* #define GSL_MACH_EPS 1.0e-15 */ ++#define GSL_SQRT_MACH_EPS 3.2e-08 ++#define GSL_ROOT3_MACH_EPS 1.0e-05 ++#define GSL_ROOT4_MACH_EPS 0.000178 ++#define GSL_ROOT5_MACH_EPS 0.00100 ++#define GSL_ROOT6_MACH_EPS 0.00316 ++#define GSL_LOG_MACH_EPS (-34.54) ++ ++ ++#endif /* __GSL_MACHINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h (revision 14078) +@@ -0,0 +1,55 @@ ++/* fft/gsl_dft_complex.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_DFT_COMPLEX_H__ ++#define __GSL_DFT_COMPLEX_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_dft_complex_forward (const double data[], const size_t stride, const size_t n, ++ double result[]); ++ ++int gsl_dft_complex_backward (const double data[], const size_t stride, const size_t n, ++ double result[]); ++ ++int gsl_dft_complex_inverse (const double data[], const size_t stride, const size_t n, ++ double result[]); ++ ++int gsl_dft_complex_transform (const double data[], const size_t stride, const size_t n, ++ double result[], const gsl_fft_direction sign); ++ ++__END_DECLS ++ ++#endif /* __GSL_DFT_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_INT_H__ ++#define __GSL_BLOCK_INT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_int_struct ++{ ++ size_t size; ++ int *data; ++}; ++ ++typedef struct gsl_block_int_struct gsl_block_int; ++ ++gsl_block_int *gsl_block_int_alloc (const size_t n); ++gsl_block_int *gsl_block_int_calloc (const size_t n); ++void gsl_block_int_free (gsl_block_int * b); ++ ++int gsl_block_int_fread (FILE * stream, gsl_block_int * b); ++int gsl_block_int_fwrite (FILE * stream, const gsl_block_int * b); ++int gsl_block_int_fscanf (FILE * stream, gsl_block_int * b); ++int gsl_block_int_fprintf (FILE * stream, const gsl_block_int * b, const char *format); ++ ++int gsl_block_int_raw_fread (FILE * stream, int * b, const size_t n, const size_t stride); ++int gsl_block_int_raw_fwrite (FILE * stream, const int * b, const size_t n, const size_t stride); ++int gsl_block_int_raw_fscanf (FILE * stream, int * b, const size_t n, const size_t stride); ++int gsl_block_int_raw_fprintf (FILE * stream, const int * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_int_size (const gsl_block_int * b); ++int * gsl_block_int_data (const gsl_block_int * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_SHORT_H__ ++#define __GSL_SORT_SHORT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_short (short * data, const size_t stride, const size_t n); ++void gsl_sort_short_index (size_t * p, const short * data, const size_t stride, const size_t n); ++ ++int gsl_sort_short_smallest (short * dest, const size_t k, const short * src, const size_t stride, const size_t n); ++int gsl_sort_short_smallest_index (size_t * p, const size_t k, const short * src, const size_t stride, const size_t n); ++ ++int gsl_sort_short_largest (short * dest, const size_t k, const short * src, const size_t stride, const size_t n); ++int gsl_sort_short_largest_index (size_t * p, const size_t k, const short * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h (revision 14078) +@@ -0,0 +1,59 @@ ++/* specfunc/gsl_sf_result.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_RESULT_H__ ++#define __GSL_SF_RESULT_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_sf_result_struct { ++ double val; ++ double err; ++}; ++typedef struct gsl_sf_result_struct gsl_sf_result; ++ ++#define GSL_SF_RESULT_SET(r,v,e) do { (r)->val=(v); (r)->err=(e); } while(0) ++ ++ ++struct gsl_sf_result_e10_struct { ++ double val; ++ double err; ++ int e10; ++}; ++typedef struct gsl_sf_result_e10_struct gsl_sf_result_e10; ++ ++ ++int gsl_sf_result_smash_e(const gsl_sf_result_e10 * re, gsl_sf_result * r); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_RESULT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h (revision 14078) +@@ -0,0 +1,136 @@ ++/* fft/gsl_fft_complex.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_COMPLEX_H__ ++#define __GSL_FFT_COMPLEX_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Power of 2 routines */ ++ ++ ++int gsl_fft_complex_radix2_forward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_backward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_inverse (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_transform (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_direction sign); ++ ++int gsl_fft_complex_radix2_dif_forward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_dif_backward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_dif_inverse (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_radix2_dif_transform (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_direction sign); ++ ++/* Mixed Radix general-N routines */ ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex *twiddle[64]; ++ gsl_complex *trig; ++ } ++gsl_fft_complex_wavetable; ++ ++typedef struct ++{ ++ size_t n; ++ double *scratch; ++} ++gsl_fft_complex_workspace; ++ ++ ++gsl_fft_complex_wavetable *gsl_fft_complex_wavetable_alloc (size_t n); ++ ++void gsl_fft_complex_wavetable_free (gsl_fft_complex_wavetable * wavetable); ++ ++gsl_fft_complex_workspace *gsl_fft_complex_workspace_alloc (size_t n); ++ ++void gsl_fft_complex_workspace_free (gsl_fft_complex_workspace * workspace); ++ ++int gsl_fft_complex_memcpy (gsl_fft_complex_wavetable * dest, ++ gsl_fft_complex_wavetable * src); ++ ++ ++int gsl_fft_complex_forward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable * wavetable, ++ gsl_fft_complex_workspace * work); ++ ++int gsl_fft_complex_backward (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable * wavetable, ++ gsl_fft_complex_workspace * work); ++ ++int gsl_fft_complex_inverse (gsl_complex_packed_array data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable * wavetable, ++ gsl_fft_complex_workspace * work); ++ ++int gsl_fft_complex_transform (gsl_complex_packed_array data, ++ const size_t stride, const size_t n, ++ const gsl_fft_complex_wavetable * wavetable, ++ gsl_fft_complex_workspace * work, ++ const gsl_fft_direction sign); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* ode-initval/gsl_odeiv.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman ++ */ ++#ifndef __GSL_ODEIV_H__ ++#define __GSL_ODEIV_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Description of a system of ODEs. ++ * ++ * y' = f(t,y) = dydt(t, y) ++ * ++ * The system is specified by giving the right-hand-side ++ * of the equation and possibly a jacobian function. ++ * ++ * Some methods require the jacobian function, which calculates ++ * the matrix dfdy and the vector dfdt. The matrix dfdy conforms ++ * to the GSL standard, being a continuous range of floating point ++ * values, in row-order. ++ * ++ * As with GSL function objects, user-supplied parameter ++ * data is also present. ++ */ ++ ++typedef struct ++{ ++ int (* function) (double t, const double y[], double dydt[], void * params); ++ int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params); ++ size_t dimension; ++ void * params; ++} ++gsl_odeiv_system; ++ ++#define GSL_ODEIV_FN_EVAL(S,t,y,f) (*((S)->function))(t,y,f,(S)->params) ++#define GSL_ODEIV_JA_EVAL(S,t,y,dfdy,dfdt) (*((S)->jacobian))(t,y,dfdy,dfdt,(S)->params) ++ ++ ++/* General stepper object. ++ * ++ * Opaque object for stepping an ODE system from t to t+h. ++ * In general the object has some state which facilitates ++ * iterating the stepping operation. ++ */ ++ ++typedef struct ++{ ++ const char * name; ++ int can_use_dydt_in; ++ int gives_exact_dydt_out; ++ void * (*alloc) (size_t dim); ++ int (*apply) (void * state, size_t dim, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt); ++ int (*reset) (void * state, size_t dim); ++ unsigned int (*order) (void * state); ++ void (*free) (void * state); ++} ++gsl_odeiv_step_type; ++ ++typedef struct { ++ const gsl_odeiv_step_type * type; ++ size_t dimension; ++ void * state; ++} ++gsl_odeiv_step; ++ ++ ++/* Available stepper types. ++ * ++ * rk2 : embedded 2nd(3rd) Runge-Kutta ++ * rk4 : 4th order (classical) Runge-Kutta ++ * rkck : embedded 4th(5th) Runge-Kutta, Cash-Karp ++ * rk8pd : embedded 8th(9th) Runge-Kutta, Prince-Dormand ++ * rk2imp : implicit 2nd order Runge-Kutta at Gaussian points ++ * rk4imp : implicit 4th order Runge-Kutta at Gaussian points ++ * gear1 : M=1 implicit Gear method ++ * gear2 : M=2 implicit Gear method ++ */ ++ ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkf45; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkck; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk8pd; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2imp; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2simp; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4imp; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_bsimp; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear1; ++GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear2; ++ ++ ++/* Constructor for specialized stepper objects. ++ */ ++gsl_odeiv_step * gsl_odeiv_step_alloc(const gsl_odeiv_step_type * T, size_t dim); ++int gsl_odeiv_step_reset(gsl_odeiv_step * s); ++void gsl_odeiv_step_free(gsl_odeiv_step * s); ++ ++/* General stepper object methods. ++ */ ++const char * gsl_odeiv_step_name(const gsl_odeiv_step * s); ++unsigned int gsl_odeiv_step_order(const gsl_odeiv_step * s); ++ ++int gsl_odeiv_step_apply(gsl_odeiv_step * s, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt); ++ ++/* General step size control object. ++ * ++ * The hadjust() method controls the adjustment of ++ * step size given the result of a step and the error. ++ * Valid hadjust() methods must return one of the codes below. ++ * ++ * The general data can be used by specializations ++ * to store state and control their heuristics. ++ */ ++ ++typedef struct ++{ ++ const char * name; ++ void * (*alloc) (void); ++ int (*init) (void * state, double eps_abs, double eps_rel, double a_y, double a_dydt); ++ int (*hadjust) (void * state, size_t dim, unsigned int ord, const double y[], const double yerr[], const double yp[], double * h); ++ void (*free) (void * state); ++} ++gsl_odeiv_control_type; ++ ++typedef struct ++{ ++ const gsl_odeiv_control_type * type; ++ void * state; ++} ++gsl_odeiv_control; ++ ++/* Possible return values for an hadjust() evolution method. ++ */ ++#define GSL_ODEIV_HADJ_INC 1 /* step was increased */ ++#define GSL_ODEIV_HADJ_NIL 0 /* step unchanged */ ++#define GSL_ODEIV_HADJ_DEC (-1) /* step decreased */ ++ ++gsl_odeiv_control * gsl_odeiv_control_alloc(const gsl_odeiv_control_type * T); ++int gsl_odeiv_control_init(gsl_odeiv_control * c, double eps_abs, double eps_rel, double a_y, double a_dydt); ++void gsl_odeiv_control_free(gsl_odeiv_control * c); ++int gsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, const double y[], const double yerr[], const double dydt[], double * h); ++const char * gsl_odeiv_control_name(const gsl_odeiv_control * c); ++ ++/* Available control object constructors. ++ * ++ * The standard control object is a four parameter heuristic ++ * defined as follows: ++ * D0 = eps_abs + eps_rel * (a_y |y| + a_dydt h |y'|) ++ * D1 = |yerr| ++ * q = consistency order of method (q=4 for 4(5) embedded RK) ++ * S = safety factor (0.9 say) ++ * ++ * / (D0/D1)^(1/(q+1)) D0 >= D1 ++ * h_NEW = S h_OLD * | ++ * \ (D0/D1)^(1/q) D0 < D1 ++ * ++ * This encompasses all the standard error scaling methods. ++ * ++ * The y method is the standard method with a_y=1, a_dydt=0. ++ * The yp method is the standard method with a_y=0, a_dydt=1. ++ */ ++ ++gsl_odeiv_control * gsl_odeiv_control_standard_new(double eps_abs, double eps_rel, double a_y, double a_dydt); ++gsl_odeiv_control * gsl_odeiv_control_y_new(double eps_abs, double eps_rel); ++gsl_odeiv_control * gsl_odeiv_control_yp_new(double eps_abs, double eps_rel); ++ ++/* This controller computes errors using different absolute errors for ++ * each component ++ * ++ * D0 = eps_abs * scale_abs[i] + eps_rel * (a_y |y| + a_dydt h |y'|) ++ */ ++gsl_odeiv_control * gsl_odeiv_control_scaled_new(double eps_abs, double eps_rel, double a_y, double a_dydt, const double scale_abs[], size_t dim); ++ ++/* General evolution object. ++ */ ++typedef struct { ++ size_t dimension; ++ double * y0; ++ double * yerr; ++ double * dydt_in; ++ double * dydt_out; ++ double last_step; ++ unsigned long int count; ++ unsigned long int failed_steps; ++} ++gsl_odeiv_evolve; ++ ++/* Evolution object methods. ++ */ ++gsl_odeiv_evolve * gsl_odeiv_evolve_alloc(size_t dim); ++int gsl_odeiv_evolve_apply(gsl_odeiv_evolve * e, gsl_odeiv_control * con, gsl_odeiv_step * step, const gsl_odeiv_system * dydt, double * t, double t1, double * h, double y[]); ++int gsl_odeiv_evolve_reset(gsl_odeiv_evolve * e); ++void gsl_odeiv_evolve_free(gsl_odeiv_evolve * e); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_ODEIV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_FLOAT_H__ ++#define __GSL_PERMUTE_FLOAT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_float (const size_t * p, float * data, const size_t stride, const size_t n); ++int gsl_permute_float_inverse (const size_t * p, float * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* fft/gsl_fft_real_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_REAL_FLOAT_H__ ++#define __GSL_FFT_REAL_FLOAT_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_fft_real_float_radix2_transform (float data[], const size_t stride, const size_t n) ; ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex_float *twiddle[64]; ++ gsl_complex_float *trig; ++ } ++gsl_fft_real_wavetable_float; ++ ++typedef struct ++ { ++ size_t n; ++ float *scratch; ++ } ++gsl_fft_real_workspace_float; ++ ++gsl_fft_real_wavetable_float * gsl_fft_real_wavetable_float_alloc (size_t n); ++ ++void gsl_fft_real_wavetable_float_free (gsl_fft_real_wavetable_float * wavetable); ++ ++gsl_fft_real_workspace_float * gsl_fft_real_workspace_float_alloc (size_t n); ++ ++void gsl_fft_real_workspace_float_free (gsl_fft_real_workspace_float * workspace); ++ ++int gsl_fft_real_float_transform (float data[], const size_t stride, const size_t n, ++ const gsl_fft_real_wavetable_float * wavetable, ++ gsl_fft_real_workspace_float * work); ++ ++ ++int gsl_fft_real_float_unpack (const float real_float_coefficient[], ++ float complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_REAL_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_UINT_H__ ++#define __GSL_SORT_VECTOR_UINT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_uint (gsl_vector_uint * v); ++int gsl_sort_vector_uint_index (gsl_permutation * p, const gsl_vector_uint * v); ++ ++int gsl_sort_vector_uint_smallest (unsigned int * dest, const size_t k, const gsl_vector_uint * v); ++int gsl_sort_vector_uint_largest (unsigned int * dest, const size_t k, const gsl_vector_uint * v); ++ ++int gsl_sort_vector_uint_smallest_index (size_t * p, const size_t k, const gsl_vector_uint * v); ++int gsl_sort_vector_uint_largest_index (size_t * p, const size_t k, const gsl_vector_uint * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_ULONG_H__ ++#define __GSL_SORT_VECTOR_ULONG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_ulong (gsl_vector_ulong * v); ++int gsl_sort_vector_ulong_index (gsl_permutation * p, const gsl_vector_ulong * v); ++ ++int gsl_sort_vector_ulong_smallest (unsigned long * dest, const size_t k, const gsl_vector_ulong * v); ++int gsl_sort_vector_ulong_largest (unsigned long * dest, const size_t k, const gsl_vector_ulong * v); ++ ++int gsl_sort_vector_ulong_smallest_index (size_t * p, const size_t k, const gsl_vector_ulong * v); ++int gsl_sort_vector_ulong_largest_index (size_t * p, const size_t k, const gsl_vector_ulong * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h (revision 14078) +@@ -0,0 +1,172 @@ ++/* multifit_nlin/gsl_multifit_nlin.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MULTIFIT_NLIN_H__ ++#define __GSL_MULTIFIT_NLIN_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_multifit_gradient (const gsl_matrix * J, const gsl_vector * f, ++ gsl_vector * g); ++ ++int gsl_multifit_covar (const gsl_matrix * J, double epsrel, gsl_matrix * covar); ++ ++ ++/* Definition of vector-valued functions with parameters based on gsl_vector */ ++ ++struct gsl_multifit_function_struct ++{ ++ int (* f) (const gsl_vector * x, void * params, gsl_vector * f); ++ size_t n; /* number of functions */ ++ size_t p; /* number of independent variables */ ++ void * params; ++}; ++ ++typedef struct gsl_multifit_function_struct gsl_multifit_function ; ++ ++#define GSL_MULTIFIT_FN_EVAL(F,x,y) (*((F)->f))(x,(F)->params,(y)) ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n, size_t p); ++ int (*set) (void *state, gsl_multifit_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); ++ int (*iterate) (void *state, gsl_multifit_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); ++ void (*free) (void *state); ++ } ++gsl_multifit_fsolver_type; ++ ++typedef struct ++ { ++ const gsl_multifit_fsolver_type * type; ++ gsl_multifit_function * function ; ++ gsl_vector * x ; ++ gsl_vector * f ; ++ gsl_vector * dx ; ++ void *state; ++ } ++gsl_multifit_fsolver; ++ ++gsl_multifit_fsolver * ++gsl_multifit_fsolver_alloc (const gsl_multifit_fsolver_type * T, ++ size_t n, size_t p); ++ ++void gsl_multifit_fsolver_free (gsl_multifit_fsolver * s); ++ ++int gsl_multifit_fsolver_set (gsl_multifit_fsolver * s, ++ gsl_multifit_function * f, ++ const gsl_vector * x); ++ ++int gsl_multifit_fsolver_iterate (gsl_multifit_fsolver * s); ++ ++const char * gsl_multifit_fsolver_name (const gsl_multifit_fsolver * s); ++gsl_vector * gsl_multifit_fsolver_position (const gsl_multifit_fsolver * s); ++ ++/* Definition of vector-valued functions and gradient with parameters ++ based on gsl_vector */ ++ ++struct gsl_multifit_function_fdf_struct ++{ ++ int (* f) (const gsl_vector * x, void * params, gsl_vector * f); ++ int (* df) (const gsl_vector * x, void * params, gsl_matrix * df); ++ int (* fdf) (const gsl_vector * x, void * params, gsl_vector * f, gsl_matrix *df); ++ size_t n; /* number of functions */ ++ size_t p; /* number of independent variables */ ++ void * params; ++}; ++ ++typedef struct gsl_multifit_function_fdf_struct gsl_multifit_function_fdf ; ++ ++#define GSL_MULTIFIT_FN_EVAL_F(F,x,y) ((*((F)->f))(x,(F)->params,(y))) ++#define GSL_MULTIFIT_FN_EVAL_DF(F,x,dy) ((*((F)->df))(x,(F)->params,(dy))) ++#define GSL_MULTIFIT_FN_EVAL_F_DF(F,x,y,dy) ((*((F)->fdf))(x,(F)->params,(y),(dy))) ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n, size_t p); ++ int (*set) (void *state, gsl_multifit_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); ++ int (*iterate) (void *state, gsl_multifit_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); ++ void (*free) (void *state); ++ } ++gsl_multifit_fdfsolver_type; ++ ++typedef struct ++ { ++ const gsl_multifit_fdfsolver_type * type; ++ gsl_multifit_function_fdf * fdf ; ++ gsl_vector * x; ++ gsl_vector * f; ++ gsl_matrix * J; ++ gsl_vector * dx; ++ void *state; ++ } ++gsl_multifit_fdfsolver; ++ ++ ++gsl_multifit_fdfsolver * ++gsl_multifit_fdfsolver_alloc (const gsl_multifit_fdfsolver_type * T, ++ size_t n, size_t p); ++ ++int ++gsl_multifit_fdfsolver_set (gsl_multifit_fdfsolver * s, ++ gsl_multifit_function_fdf * fdf, ++ const gsl_vector * x); ++ ++int ++gsl_multifit_fdfsolver_iterate (gsl_multifit_fdfsolver * s); ++ ++void ++gsl_multifit_fdfsolver_free (gsl_multifit_fdfsolver * s); ++ ++const char * gsl_multifit_fdfsolver_name (const gsl_multifit_fdfsolver * s); ++gsl_vector * gsl_multifit_fdfsolver_position (const gsl_multifit_fdfsolver * s); ++ ++int gsl_multifit_test_delta (const gsl_vector * dx, const gsl_vector * x, ++ double epsabs, double epsrel); ++ ++int gsl_multifit_test_gradient (const gsl_vector * g, double epsabs); ++ ++/* extern const gsl_multifit_fsolver_type * gsl_multifit_fsolver_gradient; */ ++ ++GSL_VAR const gsl_multifit_fdfsolver_type * gsl_multifit_fdfsolver_lmder; ++GSL_VAR const gsl_multifit_fdfsolver_type * gsl_multifit_fdfsolver_lmsder; ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_MULTIFIT_NLIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h (revision 14078) +@@ -0,0 +1,66 @@ ++/* err/gsl_test.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_TEST_H__ ++#define __GSL_TEST_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void ++ gsl_test (int status, const char *test_description, ...); ++ ++void ++gsl_test_rel (double result, double expected, double relative_error, ++ const char *test_description, ...) ; ++ ++void ++gsl_test_abs (double result, double expected, double absolute_error, ++ const char *test_description, ...) ; ++ ++void ++gsl_test_factor (double result, double expected, double factor, ++ const char *test_description, ...) ; ++ ++void ++gsl_test_int (int result, int expected, const char *test_description, ...) ; ++ ++void ++gsl_test_str (const char * result, const char * expected, ++ const char *test_description, ...) ; ++ ++void ++ gsl_test_verbose (int verbose) ; ++ ++int ++ gsl_test_summary (void) ; ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_TEST_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h (revision 14078) +@@ -0,0 +1,60 @@ ++/* fft/gsl_fft.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_H__ ++#define __GSL_FFT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++#ifndef GSL_DISABLE_DEPRECATED ++typedef enum ++ { ++ forward = -1, backward = +1, ++ gsl_fft_forward = -1, gsl_fft_backward = +1 ++ } ++gsl_fft_direction; ++#else ++typedef enum ++ { ++ gsl_fft_forward = -1, gsl_fft_backward = +1 ++ } ++gsl_fft_direction; ++#endif ++ ++/* this gives the sign in the formula ++ ++ h(f) = \sum x(t) exp(+/- 2 pi i f t) ++ ++ where - is the forward transform direction and + the inverse direction */ ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h (revision 14078) +@@ -0,0 +1,172 @@ ++/* histogram/gsl_histogram2d.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_HISTOGRAM2D_H__ ++#define __GSL_HISTOGRAM2D_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ size_t nx, ny ; ++ double * xrange ; ++ double * yrange ; ++ double * bin ; ++} gsl_histogram2d ; ++ ++typedef struct { ++ size_t nx, ny ; ++ double * xrange ; ++ double * yrange ; ++ double * sum ; ++} gsl_histogram2d_pdf ; ++ ++gsl_histogram2d * gsl_histogram2d_alloc (const size_t nx, const size_t ny); ++gsl_histogram2d * gsl_histogram2d_calloc (const size_t nx, const size_t ny); ++gsl_histogram2d * gsl_histogram2d_calloc_uniform (const size_t nx, const size_t ny, ++ const double xmin, const double xmax, ++ const double ymin, const double ymax); ++ ++void gsl_histogram2d_free (gsl_histogram2d * h); ++ ++int gsl_histogram2d_increment (gsl_histogram2d * h, double x, double y); ++int gsl_histogram2d_accumulate (gsl_histogram2d * h, ++ double x, double y, double weight); ++int gsl_histogram2d_find (const gsl_histogram2d * h, ++ const double x, const double y, size_t * i, size_t * j); ++ ++double gsl_histogram2d_get (const gsl_histogram2d * h, const size_t i, const size_t j); ++int gsl_histogram2d_get_xrange (const gsl_histogram2d * h, const size_t i, ++ double * xlower, double * xupper); ++int gsl_histogram2d_get_yrange (const gsl_histogram2d * h, const size_t j, ++ double * ylower, double * yupper); ++ ++ ++double gsl_histogram2d_xmax (const gsl_histogram2d * h); ++double gsl_histogram2d_xmin (const gsl_histogram2d * h); ++size_t gsl_histogram2d_nx (const gsl_histogram2d * h); ++ ++double gsl_histogram2d_ymax (const gsl_histogram2d * h); ++double gsl_histogram2d_ymin (const gsl_histogram2d * h); ++size_t gsl_histogram2d_ny (const gsl_histogram2d * h); ++ ++void gsl_histogram2d_reset (gsl_histogram2d * h); ++ ++gsl_histogram2d * ++gsl_histogram2d_calloc_range(size_t nx, size_t ny, ++ double *xrange, double *yrange); ++ ++int ++gsl_histogram2d_set_ranges_uniform (gsl_histogram2d * h, ++ double xmin, double xmax, ++ double ymin, double ymax); ++ ++int ++gsl_histogram2d_set_ranges (gsl_histogram2d * h, ++ const double xrange[], size_t xsize, ++ const double yrange[], size_t ysize); ++ ++int ++gsl_histogram2d_memcpy(gsl_histogram2d *dest, const gsl_histogram2d *source); ++ ++gsl_histogram2d * ++gsl_histogram2d_clone(const gsl_histogram2d * source); ++ ++double ++gsl_histogram2d_max_val(const gsl_histogram2d *h); ++ ++void ++gsl_histogram2d_max_bin (const gsl_histogram2d *h, size_t *i, size_t *j); ++ ++double ++gsl_histogram2d_min_val(const gsl_histogram2d *h); ++ ++void ++gsl_histogram2d_min_bin (const gsl_histogram2d *h, size_t *i, size_t *j); ++ ++double ++gsl_histogram2d_xmean (const gsl_histogram2d * h); ++ ++double ++gsl_histogram2d_ymean (const gsl_histogram2d * h); ++ ++double ++gsl_histogram2d_xsigma (const gsl_histogram2d * h); ++ ++double ++gsl_histogram2d_ysigma (const gsl_histogram2d * h); ++ ++double ++gsl_histogram2d_cov (const gsl_histogram2d * h); ++ ++double ++gsl_histogram2d_sum (const gsl_histogram2d *h); ++ ++int ++gsl_histogram2d_equal_bins_p(const gsl_histogram2d *h1, ++ const gsl_histogram2d *h2) ; ++ ++int ++gsl_histogram2d_add(gsl_histogram2d *h1, const gsl_histogram2d *h2); ++ ++int ++gsl_histogram2d_sub(gsl_histogram2d *h1, const gsl_histogram2d *h2); ++ ++int ++gsl_histogram2d_mul(gsl_histogram2d *h1, const gsl_histogram2d *h2); ++ ++int ++gsl_histogram2d_div(gsl_histogram2d *h1, const gsl_histogram2d *h2); ++ ++int ++gsl_histogram2d_scale(gsl_histogram2d *h, double scale); ++ ++int ++gsl_histogram2d_shift(gsl_histogram2d *h, double shift); ++ ++int gsl_histogram2d_fwrite (FILE * stream, const gsl_histogram2d * h) ; ++int gsl_histogram2d_fread (FILE * stream, gsl_histogram2d * h); ++int gsl_histogram2d_fprintf (FILE * stream, const gsl_histogram2d * h, ++ const char * range_format, ++ const char * bin_format); ++int gsl_histogram2d_fscanf (FILE * stream, gsl_histogram2d * h); ++ ++gsl_histogram2d_pdf * gsl_histogram2d_pdf_alloc (const size_t nx, const size_t ny); ++int gsl_histogram2d_pdf_init (gsl_histogram2d_pdf * p, const gsl_histogram2d * h); ++void gsl_histogram2d_pdf_free (gsl_histogram2d_pdf * p); ++int gsl_histogram2d_pdf_sample (const gsl_histogram2d_pdf * p, ++ double r1, double r2, ++ double * x, double * y); ++ ++__END_DECLS ++ ++#endif /* __GSL_HISTOGRAM2D_H__ */ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_UCHAR_H__ ++#define __GSL_VECTOR_UCHAR_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ unsigned char *data; ++ gsl_block_uchar *block; ++ int owner; ++} ++gsl_vector_uchar; ++ ++typedef struct ++{ ++ gsl_vector_uchar vector; ++} _gsl_vector_uchar_view; ++ ++typedef _gsl_vector_uchar_view gsl_vector_uchar_view; ++ ++typedef struct ++{ ++ gsl_vector_uchar vector; ++} _gsl_vector_uchar_const_view; ++ ++typedef const _gsl_vector_uchar_const_view gsl_vector_uchar_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_uchar *gsl_vector_uchar_alloc (const size_t n); ++gsl_vector_uchar *gsl_vector_uchar_calloc (const size_t n); ++ ++gsl_vector_uchar *gsl_vector_uchar_alloc_from_block (gsl_block_uchar * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_uchar *gsl_vector_uchar_alloc_from_vector (gsl_vector_uchar * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_uchar_free (gsl_vector_uchar * v); ++ ++/* Views */ ++ ++_gsl_vector_uchar_view ++gsl_vector_uchar_view_array (unsigned char *v, size_t n); ++ ++_gsl_vector_uchar_view ++gsl_vector_uchar_view_array_with_stride (unsigned char *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uchar_const_view ++gsl_vector_uchar_const_view_array (const unsigned char *v, size_t n); ++ ++_gsl_vector_uchar_const_view ++gsl_vector_uchar_const_view_array_with_stride (const unsigned char *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uchar_view ++gsl_vector_uchar_subvector (gsl_vector_uchar *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_uchar_view ++gsl_vector_uchar_subvector_with_stride (gsl_vector_uchar *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uchar_const_view ++gsl_vector_uchar_const_subvector (const gsl_vector_uchar *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_uchar_const_view ++gsl_vector_uchar_const_subvector_with_stride (const gsl_vector_uchar *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_uchar_set_zero (gsl_vector_uchar * v); ++void gsl_vector_uchar_set_all (gsl_vector_uchar * v, unsigned char x); ++int gsl_vector_uchar_set_basis (gsl_vector_uchar * v, size_t i); ++ ++int gsl_vector_uchar_fread (FILE * stream, gsl_vector_uchar * v); ++int gsl_vector_uchar_fwrite (FILE * stream, const gsl_vector_uchar * v); ++int gsl_vector_uchar_fscanf (FILE * stream, gsl_vector_uchar * v); ++int gsl_vector_uchar_fprintf (FILE * stream, const gsl_vector_uchar * v, ++ const char *format); ++ ++int gsl_vector_uchar_memcpy (gsl_vector_uchar * dest, const gsl_vector_uchar * src); ++ ++int gsl_vector_uchar_reverse (gsl_vector_uchar * v); ++ ++int gsl_vector_uchar_swap (gsl_vector_uchar * v, gsl_vector_uchar * w); ++int gsl_vector_uchar_swap_elements (gsl_vector_uchar * v, const size_t i, const size_t j); ++ ++unsigned char gsl_vector_uchar_max (const gsl_vector_uchar * v); ++unsigned char gsl_vector_uchar_min (const gsl_vector_uchar * v); ++void gsl_vector_uchar_minmax (const gsl_vector_uchar * v, unsigned char * min_out, unsigned char * max_out); ++ ++size_t gsl_vector_uchar_max_index (const gsl_vector_uchar * v); ++size_t gsl_vector_uchar_min_index (const gsl_vector_uchar * v); ++void gsl_vector_uchar_minmax_index (const gsl_vector_uchar * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_uchar_add (gsl_vector_uchar * a, const gsl_vector_uchar * b); ++int gsl_vector_uchar_sub (gsl_vector_uchar * a, const gsl_vector_uchar * b); ++int gsl_vector_uchar_mul (gsl_vector_uchar * a, const gsl_vector_uchar * b); ++int gsl_vector_uchar_div (gsl_vector_uchar * a, const gsl_vector_uchar * b); ++int gsl_vector_uchar_scale (gsl_vector_uchar * a, const double x); ++int gsl_vector_uchar_add_constant (gsl_vector_uchar * a, const double x); ++ ++int gsl_vector_uchar_equal (const gsl_vector_uchar * u, ++ const gsl_vector_uchar * v); ++ ++int gsl_vector_uchar_isnull (const gsl_vector_uchar * v); ++int gsl_vector_uchar_ispos (const gsl_vector_uchar * v); ++int gsl_vector_uchar_isneg (const gsl_vector_uchar * v); ++int gsl_vector_uchar_isnonneg (const gsl_vector_uchar * v); ++ ++INLINE_DECL unsigned char gsl_vector_uchar_get (const gsl_vector_uchar * v, const size_t i); ++INLINE_DECL void gsl_vector_uchar_set (gsl_vector_uchar * v, const size_t i, unsigned char x); ++INLINE_DECL unsigned char * gsl_vector_uchar_ptr (gsl_vector_uchar * v, const size_t i); ++INLINE_DECL const unsigned char * gsl_vector_uchar_const_ptr (const gsl_vector_uchar * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++unsigned char ++gsl_vector_uchar_get (const gsl_vector_uchar * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_uchar_set (gsl_vector_uchar * v, const size_t i, unsigned char x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++unsigned char * ++gsl_vector_uchar_ptr (gsl_vector_uchar * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (unsigned char *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const unsigned char * ++gsl_vector_uchar_const_ptr (const gsl_vector_uchar * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const unsigned char *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_UCHAR_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h (revision 14078) +@@ -0,0 +1,107 @@ ++/* specfunc/gsl_sf_mathieu.h ++ * ++ * Copyright (C) 2002 Lowell Johnson ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ */ ++ ++/* Author: L. Johnson */ ++ ++#ifndef __GSL_SF_MATHIEU_H__ ++#define __GSL_SF_MATHIEU_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++#define GSL_SF_MATHIEU_COEFF 100 ++ ++typedef struct ++{ ++ size_t size; ++ size_t even_order; ++ size_t odd_order; ++ int extra_values; ++ double qa; /* allow for caching of results: not implemented yet */ ++ double qb; /* allow for caching of results: not implemented yet */ ++ double *aa; ++ double *bb; ++ double *dd; ++ double *ee; ++ double *tt; ++ double *e2; ++ double *zz; ++ gsl_vector *eval; ++ gsl_matrix *evec; ++ gsl_eigen_symmv_workspace *wmat; ++} gsl_sf_mathieu_workspace; ++ ++ ++/* Compute an array of characteristic (eigen) values from the recurrence ++ matrices for the Mathieu equations. */ ++int gsl_sf_mathieu_a_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]); ++int gsl_sf_mathieu_b_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]); ++ ++/* Compute the characteristic value for a Mathieu function of order n and ++ type ntype. */ ++int gsl_sf_mathieu_a(int order, double qq, gsl_sf_result *result); ++int gsl_sf_mathieu_b(int order, double qq, gsl_sf_result *result); ++ ++/* Compute the Fourier coefficients for a Mathieu function. */ ++int gsl_sf_mathieu_a_coeff(int order, double qq, double aa, double coeff[]); ++int gsl_sf_mathieu_b_coeff(int order, double qq, double aa, double coeff[]); ++ ++/* Allocate computational storage space for eigenvalue solution. */ ++gsl_sf_mathieu_workspace *gsl_sf_mathieu_alloc(const size_t nn, ++ const double qq); ++void gsl_sf_mathieu_free(gsl_sf_mathieu_workspace *workspace); ++ ++/* Compute an angular Mathieu function. */ ++int gsl_sf_mathieu_ce(int order, double qq, double zz, gsl_sf_result *result); ++int gsl_sf_mathieu_se(int order, double qq, double zz, gsl_sf_result *result); ++int gsl_sf_mathieu_ce_array(int nmin, int nmax, double qq, double zz, ++ gsl_sf_mathieu_workspace *work, ++ double result_array[]); ++int gsl_sf_mathieu_se_array(int nmin, int nmax, double qq, double zz, ++ gsl_sf_mathieu_workspace *work, ++ double result_array[]); ++ ++/* Compute a radial Mathieu function. */ ++int gsl_sf_mathieu_Mc(int kind, int order, double qq, double zz, ++ gsl_sf_result *result); ++int gsl_sf_mathieu_Ms(int kind, int order, double qq, double zz, ++ gsl_sf_result *result); ++int gsl_sf_mathieu_Mc_array(int kind, int nmin, int nmax, double qq, ++ double zz, gsl_sf_mathieu_workspace *work, ++ double result_array[]); ++int gsl_sf_mathieu_Ms_array(int kind, int nmin, int nmax, double qq, ++ double zz, gsl_sf_mathieu_workspace *work, ++ double result_array[]); ++ ++ ++__END_DECLS ++ ++#endif /* !__GSL_SF_MATHIEU_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* sort/gsl_heapsort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_HEAPSORT_H__ ++#define __GSL_HEAPSORT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef int (*gsl_comparison_fn_t) (const void *, const void *); ++ ++void gsl_heapsort (void * array, size_t count, size_t size, gsl_comparison_fn_t compare); ++int gsl_heapsort_index (size_t * p, const void * array, size_t count, size_t size, gsl_comparison_fn_t compare); ++ ++__END_DECLS ++ ++#endif /* __GSL_HEAPSORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h (revision 14078) +@@ -0,0 +1,20 @@ ++#ifndef __GSL_SORT_H__ ++#define __GSL_SORT_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_SORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h (revision 14078) +@@ -0,0 +1,347 @@ ++/* eigen/gsl_eigen.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2006, 2007 Gerard Jungman, Brian Gough, Patrick Alken ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_EIGEN_H__ ++#define __GSL_EIGEN_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ size_t size; ++ double * d; ++ double * sd; ++} gsl_eigen_symm_workspace; ++ ++gsl_eigen_symm_workspace * gsl_eigen_symm_alloc (const size_t n); ++void gsl_eigen_symm_free (gsl_eigen_symm_workspace * w); ++int gsl_eigen_symm (gsl_matrix * A, gsl_vector * eval, gsl_eigen_symm_workspace * w); ++ ++typedef struct { ++ size_t size; ++ double * d; ++ double * sd; ++ double * gc; ++ double * gs; ++} gsl_eigen_symmv_workspace; ++ ++gsl_eigen_symmv_workspace * gsl_eigen_symmv_alloc (const size_t n); ++void gsl_eigen_symmv_free (gsl_eigen_symmv_workspace * w); ++int gsl_eigen_symmv (gsl_matrix * A, gsl_vector * eval, gsl_matrix * evec, gsl_eigen_symmv_workspace * w); ++ ++typedef struct { ++ size_t size; ++ double * d; ++ double * sd; ++ double * tau; ++} gsl_eigen_herm_workspace; ++ ++gsl_eigen_herm_workspace * gsl_eigen_herm_alloc (const size_t n); ++void gsl_eigen_herm_free (gsl_eigen_herm_workspace * w); ++int gsl_eigen_herm (gsl_matrix_complex * A, gsl_vector * eval, ++ gsl_eigen_herm_workspace * w); ++ ++typedef struct { ++ size_t size; ++ double * d; ++ double * sd; ++ double * tau; ++ double * gc; ++ double * gs; ++} gsl_eigen_hermv_workspace; ++ ++gsl_eigen_hermv_workspace * gsl_eigen_hermv_alloc (const size_t n); ++void gsl_eigen_hermv_free (gsl_eigen_hermv_workspace * w); ++int gsl_eigen_hermv (gsl_matrix_complex * A, gsl_vector * eval, ++ gsl_matrix_complex * evec, ++ gsl_eigen_hermv_workspace * w); ++ ++typedef struct { ++ size_t size; /* matrix size */ ++ size_t max_iterations; /* max iterations since last eigenvalue found */ ++ size_t n_iter; /* number of iterations since last eigenvalue found */ ++ size_t n_evals; /* number of eigenvalues found so far */ ++ ++ int compute_t; /* compute Schur form T = Z^t A Z */ ++ ++ gsl_matrix *H; /* pointer to Hessenberg matrix */ ++ gsl_matrix *Z; /* pointer to Schur vector matrix */ ++} gsl_eigen_francis_workspace; ++ ++gsl_eigen_francis_workspace * gsl_eigen_francis_alloc (void); ++void gsl_eigen_francis_free (gsl_eigen_francis_workspace * w); ++void gsl_eigen_francis_T (const int compute_t, ++ gsl_eigen_francis_workspace * w); ++int gsl_eigen_francis (gsl_matrix * H, gsl_vector_complex * eval, ++ gsl_eigen_francis_workspace * w); ++int gsl_eigen_francis_Z (gsl_matrix * H, gsl_vector_complex * eval, ++ gsl_matrix * Z, ++ gsl_eigen_francis_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_vector *diag; /* diagonal matrix elements from balancing */ ++ gsl_vector *tau; /* Householder coefficients */ ++ gsl_matrix *Z; /* pointer to Z matrix */ ++ int do_balance; /* perform balancing transformation? */ ++ size_t n_evals; /* number of eigenvalues found */ ++ ++ gsl_eigen_francis_workspace *francis_workspace_p; ++} gsl_eigen_nonsymm_workspace; ++ ++gsl_eigen_nonsymm_workspace * gsl_eigen_nonsymm_alloc (const size_t n); ++void gsl_eigen_nonsymm_free (gsl_eigen_nonsymm_workspace * w); ++void gsl_eigen_nonsymm_params (const int compute_t, const int balance, ++ gsl_eigen_nonsymm_workspace *w); ++int gsl_eigen_nonsymm (gsl_matrix * A, gsl_vector_complex * eval, ++ gsl_eigen_nonsymm_workspace * w); ++int gsl_eigen_nonsymm_Z (gsl_matrix * A, gsl_vector_complex * eval, ++ gsl_matrix * Z, gsl_eigen_nonsymm_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_vector *work; /* scratch workspace */ ++ gsl_vector *work2; /* scratch workspace */ ++ gsl_vector *work3; /* scratch workspace */ ++ ++ gsl_matrix *Z; /* pointer to Schur vectors */ ++ ++ gsl_eigen_nonsymm_workspace *nonsymm_workspace_p; ++} gsl_eigen_nonsymmv_workspace; ++ ++gsl_eigen_nonsymmv_workspace * gsl_eigen_nonsymmv_alloc (const size_t n); ++void gsl_eigen_nonsymmv_free (gsl_eigen_nonsymmv_workspace * w); ++void gsl_eigen_nonsymmv_params (const int balance, ++ gsl_eigen_nonsymmv_workspace *w); ++int gsl_eigen_nonsymmv (gsl_matrix * A, gsl_vector_complex * eval, ++ gsl_matrix_complex * evec, ++ gsl_eigen_nonsymmv_workspace * w); ++int gsl_eigen_nonsymmv_Z (gsl_matrix * A, gsl_vector_complex * eval, ++ gsl_matrix_complex * evec, gsl_matrix * Z, ++ gsl_eigen_nonsymmv_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_eigen_symm_workspace *symm_workspace_p; ++} gsl_eigen_gensymm_workspace; ++ ++gsl_eigen_gensymm_workspace * gsl_eigen_gensymm_alloc (const size_t n); ++void gsl_eigen_gensymm_free (gsl_eigen_gensymm_workspace * w); ++int gsl_eigen_gensymm (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector * eval, gsl_eigen_gensymm_workspace * w); ++int gsl_eigen_gensymm_standardize (gsl_matrix * A, const gsl_matrix * B); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_eigen_symmv_workspace *symmv_workspace_p; ++} gsl_eigen_gensymmv_workspace; ++ ++gsl_eigen_gensymmv_workspace * gsl_eigen_gensymmv_alloc (const size_t n); ++void gsl_eigen_gensymmv_free (gsl_eigen_gensymmv_workspace * w); ++int gsl_eigen_gensymmv (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector * eval, gsl_matrix * evec, ++ gsl_eigen_gensymmv_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_eigen_herm_workspace *herm_workspace_p; ++} gsl_eigen_genherm_workspace; ++ ++gsl_eigen_genherm_workspace * gsl_eigen_genherm_alloc (const size_t n); ++void gsl_eigen_genherm_free (gsl_eigen_genherm_workspace * w); ++int gsl_eigen_genherm (gsl_matrix_complex * A, gsl_matrix_complex * B, ++ gsl_vector * eval, gsl_eigen_genherm_workspace * w); ++int gsl_eigen_genherm_standardize (gsl_matrix_complex * A, ++ const gsl_matrix_complex * B); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_eigen_hermv_workspace *hermv_workspace_p; ++} gsl_eigen_genhermv_workspace; ++ ++gsl_eigen_genhermv_workspace * gsl_eigen_genhermv_alloc (const size_t n); ++void gsl_eigen_genhermv_free (gsl_eigen_genhermv_workspace * w); ++int gsl_eigen_genhermv (gsl_matrix_complex * A, gsl_matrix_complex * B, ++ gsl_vector * eval, gsl_matrix_complex * evec, ++ gsl_eigen_genhermv_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ gsl_vector *work; /* scratch workspace */ ++ ++ size_t n_evals; /* number of eigenvalues found */ ++ size_t max_iterations; /* maximum QZ iterations allowed */ ++ size_t n_iter; /* number of iterations since last eigenvalue found */ ++ double eshift; /* exceptional shift counter */ ++ ++ int needtop; /* need to compute top index? */ ++ ++ double atol; /* tolerance for splitting A matrix */ ++ double btol; /* tolerance for splitting B matrix */ ++ ++ double ascale; /* scaling factor for shifts */ ++ double bscale; /* scaling factor for shifts */ ++ ++ gsl_matrix *H; /* pointer to hessenberg matrix */ ++ gsl_matrix *R; /* pointer to upper triangular matrix */ ++ ++ int compute_s; /* compute generalized Schur form S */ ++ int compute_t; /* compute generalized Schur form T */ ++ ++ gsl_matrix *Q; /* pointer to left Schur vectors */ ++ gsl_matrix *Z; /* pointer to right Schur vectors */ ++} gsl_eigen_gen_workspace; ++ ++gsl_eigen_gen_workspace * gsl_eigen_gen_alloc (const size_t n); ++void gsl_eigen_gen_free (gsl_eigen_gen_workspace * w); ++void gsl_eigen_gen_params (const int compute_s, const int compute_t, ++ const int balance, gsl_eigen_gen_workspace * w); ++int gsl_eigen_gen (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector_complex * alpha, gsl_vector * beta, ++ gsl_eigen_gen_workspace * w); ++int gsl_eigen_gen_QZ (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector_complex * alpha, gsl_vector * beta, ++ gsl_matrix * Q, gsl_matrix * Z, ++ gsl_eigen_gen_workspace * w); ++ ++typedef struct { ++ size_t size; /* size of matrices */ ++ ++ gsl_vector *work1; /* 1-norm of columns of A */ ++ gsl_vector *work2; /* 1-norm of columns of B */ ++ gsl_vector *work3; /* real part of eigenvector */ ++ gsl_vector *work4; /* imag part of eigenvector */ ++ gsl_vector *work5; /* real part of back-transformed eigenvector */ ++ gsl_vector *work6; /* imag part of back-transformed eigenvector */ ++ ++ gsl_matrix *Q; /* pointer to left Schur vectors */ ++ gsl_matrix *Z; /* pointer to right Schur vectors */ ++ ++ gsl_eigen_gen_workspace *gen_workspace_p; ++} gsl_eigen_genv_workspace; ++ ++gsl_eigen_genv_workspace * gsl_eigen_genv_alloc (const size_t n); ++void gsl_eigen_genv_free (gsl_eigen_genv_workspace * w); ++int gsl_eigen_genv (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector_complex * alpha, gsl_vector * beta, ++ gsl_matrix_complex * evec, ++ gsl_eigen_genv_workspace * w); ++int gsl_eigen_genv_QZ (gsl_matrix * A, gsl_matrix * B, ++ gsl_vector_complex * alpha, gsl_vector * beta, ++ gsl_matrix_complex * evec, ++ gsl_matrix * Q, gsl_matrix * Z, ++ gsl_eigen_genv_workspace * w); ++ ++ ++ ++typedef enum { ++ GSL_EIGEN_SORT_VAL_ASC, ++ GSL_EIGEN_SORT_VAL_DESC, ++ GSL_EIGEN_SORT_ABS_ASC, ++ GSL_EIGEN_SORT_ABS_DESC ++} ++gsl_eigen_sort_t; ++ ++/* Sort eigensystem results based on eigenvalues. ++ * Sorts in order of increasing value or increasing ++ * absolute value. ++ * ++ * exceptions: GSL_EBADLEN ++ */ ++ ++int gsl_eigen_symmv_sort(gsl_vector * eval, gsl_matrix * evec, ++ gsl_eigen_sort_t sort_type); ++ ++int gsl_eigen_hermv_sort(gsl_vector * eval, gsl_matrix_complex * evec, ++ gsl_eigen_sort_t sort_type); ++ ++int gsl_eigen_nonsymmv_sort(gsl_vector_complex * eval, ++ gsl_matrix_complex * evec, ++ gsl_eigen_sort_t sort_type); ++ ++int gsl_eigen_gensymmv_sort (gsl_vector * eval, gsl_matrix * evec, ++ gsl_eigen_sort_t sort_type); ++ ++int gsl_eigen_genhermv_sort (gsl_vector * eval, gsl_matrix_complex * evec, ++ gsl_eigen_sort_t sort_type); ++ ++int gsl_eigen_genv_sort (gsl_vector_complex * alpha, gsl_vector * beta, ++ gsl_matrix_complex * evec, ++ gsl_eigen_sort_t sort_type); ++ ++/* Prototypes for the schur module */ ++ ++int gsl_schur_gen_eigvals(const gsl_matrix *A, const gsl_matrix *B, ++ double *wr1, double *wr2, double *wi, ++ double *scale1, double *scale2); ++ ++int gsl_schur_solve_equation(double ca, const gsl_matrix *A, double z, ++ double d1, double d2, const gsl_vector *b, ++ gsl_vector *x, double *s, double *xnorm, ++ double smin); ++ ++int gsl_schur_solve_equation_z(double ca, const gsl_matrix *A, ++ gsl_complex *z, double d1, double d2, ++ const gsl_vector_complex *b, ++ gsl_vector_complex *x, double *s, ++ double *xnorm, double smin); ++ ++ ++/* The following functions are obsolete: */ ++ ++/* Eigensolve by Jacobi Method ++ * ++ * The data in the matrix input is destroyed. ++ * ++ * exceptions: ++ */ ++int ++gsl_eigen_jacobi(gsl_matrix * matrix, ++ gsl_vector * eval, ++ gsl_matrix * evec, ++ unsigned int max_rot, ++ unsigned int * nrot); ++ ++ ++/* Invert by Jacobi Method ++ * ++ * exceptions: ++ */ ++int ++gsl_eigen_invert_jacobi(const gsl_matrix * matrix, ++ gsl_matrix * ainv, ++ unsigned int max_rot); ++ ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_EIGEN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_LONG_H__ ++#define __GSL_SORT_VECTOR_LONG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_long (gsl_vector_long * v); ++int gsl_sort_vector_long_index (gsl_permutation * p, const gsl_vector_long * v); ++ ++int gsl_sort_vector_long_smallest (long * dest, const size_t k, const gsl_vector_long * v); ++int gsl_sort_vector_long_largest (long * dest, const size_t k, const gsl_vector_long * v); ++ ++int gsl_sort_vector_long_smallest_index (size_t * p, const size_t k, const gsl_vector_long * v); ++int gsl_sort_vector_long_largest_index (size_t * p, const size_t k, const gsl_vector_long * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h (revision 14078) +@@ -0,0 +1,101 @@ ++/* interpolation/gsl_spline.h ++ * ++ * Copyright (C) 2001, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SPLINE_H__ ++#define __GSL_SPLINE_H__ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* general interpolation object */ ++typedef struct { ++ gsl_interp * interp; ++ double * x; ++ double * y; ++ size_t size; ++} gsl_spline; ++ ++gsl_spline * ++gsl_spline_alloc(const gsl_interp_type * T, size_t size); ++ ++int ++gsl_spline_init(gsl_spline * spline, const double xa[], const double ya[], size_t size); ++ ++const char * gsl_spline_name(const gsl_spline * spline); ++unsigned int gsl_spline_min_size(const gsl_spline * spline); ++ ++ ++int ++gsl_spline_eval_e(const gsl_spline * spline, double x, ++ gsl_interp_accel * a, double * y); ++ ++double ++gsl_spline_eval(const gsl_spline * spline, double x, gsl_interp_accel * a); ++ ++int ++gsl_spline_eval_deriv_e(const gsl_spline * spline, ++ double x, ++ gsl_interp_accel * a, ++ double * y); ++ ++double ++gsl_spline_eval_deriv(const gsl_spline * spline, ++ double x, ++ gsl_interp_accel * a); ++ ++int ++gsl_spline_eval_deriv2_e(const gsl_spline * spline, ++ double x, ++ gsl_interp_accel * a, ++ double * y); ++ ++double ++gsl_spline_eval_deriv2(const gsl_spline * spline, ++ double x, ++ gsl_interp_accel * a); ++ ++int ++gsl_spline_eval_integ_e(const gsl_spline * spline, ++ double a, double b, ++ gsl_interp_accel * acc, ++ double * y); ++ ++double ++gsl_spline_eval_integ(const gsl_spline * spline, ++ double a, double b, ++ gsl_interp_accel * acc); ++ ++void ++gsl_spline_free(gsl_spline * spline); ++ ++__END_DECLS ++ ++#endif /* __GSL_INTERP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h (revision 14078) +@@ -0,0 +1,114 @@ ++/* bspline/gsl_bspline.h ++ * ++ * Copyright (C) 2006 Patrick Alken ++ * Copyright (C) 2008 Rhys Ulerich ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BSPLINE_H__ ++#define __GSL_BSPLINE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t k; /* spline order */ ++ size_t km1; /* k - 1 (polynomial order) */ ++ size_t l; /* number of polynomial pieces on interval */ ++ size_t nbreak; /* number of breakpoints (l + 1) */ ++ size_t n; /* number of bspline basis functions (l + k - 1) */ ++ ++ gsl_vector *knots; /* knots vector */ ++ gsl_vector *deltal; /* left delta */ ++ gsl_vector *deltar; /* right delta */ ++ gsl_vector *B; /* temporary spline results */ ++} gsl_bspline_workspace; ++ ++typedef struct ++{ ++ size_t k; /* spline order */ ++ gsl_matrix *A; /* work matrix */ ++ gsl_matrix *dB; /* temporary derivative results */ ++} gsl_bspline_deriv_workspace; ++ ++gsl_bspline_workspace * ++gsl_bspline_alloc(const size_t k, const size_t nbreak); ++ ++void gsl_bspline_free(gsl_bspline_workspace *w); ++ ++size_t gsl_bspline_ncoeffs(gsl_bspline_workspace * w); ++size_t gsl_bspline_order(gsl_bspline_workspace * w); ++size_t gsl_bspline_nbreak(gsl_bspline_workspace * w); ++double gsl_bspline_breakpoint(size_t i, gsl_bspline_workspace * w); ++double gsl_bspline_greville_abscissa(size_t i, gsl_bspline_workspace *w); ++ ++int ++gsl_bspline_knots(const gsl_vector *breakpts, gsl_bspline_workspace *w); ++ ++int gsl_bspline_knots_uniform(const double a, const double b, ++ gsl_bspline_workspace *w); ++ ++int ++gsl_bspline_eval(const double x, gsl_vector *B, ++ gsl_bspline_workspace *w); ++ ++int ++gsl_bspline_eval_nonzero(const double x, ++ gsl_vector *Bk, ++ size_t *istart, ++ size_t *iend, ++ gsl_bspline_workspace *w); ++ ++gsl_bspline_deriv_workspace * ++gsl_bspline_deriv_alloc(const size_t k); ++ ++void ++gsl_bspline_deriv_free(gsl_bspline_deriv_workspace *w); ++ ++int ++gsl_bspline_deriv_eval(const double x, ++ const size_t nderiv, ++ gsl_matrix *dB, ++ gsl_bspline_workspace *w, ++ gsl_bspline_deriv_workspace *dw); ++ ++int ++gsl_bspline_deriv_eval_nonzero(const double x, ++ const size_t nderiv, ++ gsl_matrix *dB, ++ size_t *istart, ++ size_t *iend, ++ gsl_bspline_workspace *w, ++ gsl_bspline_deriv_workspace *dw); ++ ++__END_DECLS ++ ++#endif /* __GSL_BSPLINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h (revision 14078) +@@ -0,0 +1,152 @@ ++/* specfunc/gsl_sf_trig.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_TRIG_H__ ++#define __GSL_SF_TRIG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Sin(x) with GSL semantics. This is actually important ++ * because we want to control the error estimate, and trying ++ * to guess the error for the standard library implementation ++ * every time it is used would be a little goofy. ++ */ ++int gsl_sf_sin_e(double x, gsl_sf_result * result); ++double gsl_sf_sin(const double x); ++ ++ ++/* Cos(x) with GSL semantics. ++ */ ++int gsl_sf_cos_e(double x, gsl_sf_result * result); ++double gsl_sf_cos(const double x); ++ ++ ++/* Hypot(x,y) with GSL semantics. ++ */ ++int gsl_sf_hypot_e(const double x, const double y, gsl_sf_result * result); ++double gsl_sf_hypot(const double x, const double y); ++ ++ ++/* Sin(z) for complex z ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_complex_sin_e(const double zr, const double zi, gsl_sf_result * szr, gsl_sf_result * szi); ++ ++ ++/* Cos(z) for complex z ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_complex_cos_e(const double zr, const double zi, gsl_sf_result * czr, gsl_sf_result * czi); ++ ++ ++/* Log(Sin(z)) for complex z ++ * ++ * exceptions: GSL_EDOM, GSL_ELOSS ++ */ ++int gsl_sf_complex_logsin_e(const double zr, const double zi, gsl_sf_result * lszr, gsl_sf_result * lszi); ++ ++ ++/* Sinc(x) = sin(pi x) / (pi x) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_sinc_e(double x, gsl_sf_result * result); ++double gsl_sf_sinc(const double x); ++ ++ ++/* Log(Sinh(x)), x > 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_lnsinh_e(const double x, gsl_sf_result * result); ++double gsl_sf_lnsinh(const double x); ++ ++ ++/* Log(Cosh(x)) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_lncosh_e(const double x, gsl_sf_result * result); ++double gsl_sf_lncosh(const double x); ++ ++ ++/* Convert polar to rectlinear coordinates. ++ * ++ * exceptions: GSL_ELOSS ++ */ ++int gsl_sf_polar_to_rect(const double r, const double theta, gsl_sf_result * x, gsl_sf_result * y); ++ ++/* Convert rectilinear to polar coordinates. ++ * return argument in range [-pi, pi] ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_rect_to_polar(const double x, const double y, gsl_sf_result * r, gsl_sf_result * theta); ++ ++/* Sin(x) for quantity with an associated error. ++ */ ++int gsl_sf_sin_err_e(const double x, const double dx, gsl_sf_result * result); ++ ++ ++/* Cos(x) for quantity with an associated error. ++ */ ++int gsl_sf_cos_err_e(const double x, const double dx, gsl_sf_result * result); ++ ++ ++/* Force an angle to lie in the range (-pi,pi]. ++ * ++ * exceptions: GSL_ELOSS ++ */ ++int gsl_sf_angle_restrict_symm_e(double * theta); ++double gsl_sf_angle_restrict_symm(const double theta); ++ ++ ++/* Force an angle to lie in the range [0, 2pi) ++ * ++ * exceptions: GSL_ELOSS ++ */ ++int gsl_sf_angle_restrict_pos_e(double * theta); ++double gsl_sf_angle_restrict_pos(const double theta); ++ ++ ++int gsl_sf_angle_restrict_symm_err_e(const double theta, gsl_sf_result * result); ++ ++int gsl_sf_angle_restrict_pos_err_e(const double theta, gsl_sf_result * result); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_TRIG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h (revision 14078) +@@ -0,0 +1,57 @@ ++/* specfunc/gsl_sf_elementary.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++/* Miscellaneous elementary functions and operations. ++ */ ++#ifndef __GSL_SF_ELEMENTARY_H__ ++#define __GSL_SF_ELEMENTARY_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Multiplication. ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_multiply_e(const double x, const double y, gsl_sf_result * result); ++double gsl_sf_multiply(const double x, const double y); ++ ++ ++/* Multiplication of quantities with associated errors. ++ */ ++int gsl_sf_multiply_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_ELEMENTARY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_FLOAT_H__ ++#define __GSL_SORT_VECTOR_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_float (gsl_vector_float * v); ++int gsl_sort_vector_float_index (gsl_permutation * p, const gsl_vector_float * v); ++ ++int gsl_sort_vector_float_smallest (float * dest, const size_t k, const gsl_vector_float * v); ++int gsl_sort_vector_float_largest (float * dest, const size_t k, const gsl_vector_float * v); ++ ++int gsl_sort_vector_float_smallest_index (size_t * p, const size_t k, const gsl_vector_float * v); ++int gsl_sort_vector_float_largest_index (size_t * p, const size_t k, const gsl_vector_float * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h (revision 14078) +@@ -0,0 +1,68 @@ ++/* specfunc/gsl_sf_laguerre.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_LAGUERRE_H__ ++#define __GSL_SF_LAGUERRE_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* L^a_n(x) = (a+1)_n / n! 1F1(-n,a+1,x) */ ++ ++ ++/* Evaluate generalized Laguerre polynomials ++ * using explicit representations. ++ * ++ * exceptions: none ++ */ ++int gsl_sf_laguerre_1_e(const double a, const double x, gsl_sf_result * result); ++int gsl_sf_laguerre_2_e(const double a, const double x, gsl_sf_result * result); ++int gsl_sf_laguerre_3_e(const double a, const double x, gsl_sf_result * result); ++double gsl_sf_laguerre_1(double a, double x); ++double gsl_sf_laguerre_2(double a, double x); ++double gsl_sf_laguerre_3(double a, double x); ++ ++ ++/* Evaluate generalized Laguerre polynomials. ++ * ++ * a > -1.0 ++ * n >= 0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_laguerre_n_e(const int n, const double a, const double x, gsl_sf_result * result); ++double gsl_sf_laguerre_n(int n, double a, double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_LAGUERRE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_USHORT_H__ ++#define __GSL_BLOCK_USHORT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_ushort_struct ++{ ++ size_t size; ++ unsigned short *data; ++}; ++ ++typedef struct gsl_block_ushort_struct gsl_block_ushort; ++ ++gsl_block_ushort *gsl_block_ushort_alloc (const size_t n); ++gsl_block_ushort *gsl_block_ushort_calloc (const size_t n); ++void gsl_block_ushort_free (gsl_block_ushort * b); ++ ++int gsl_block_ushort_fread (FILE * stream, gsl_block_ushort * b); ++int gsl_block_ushort_fwrite (FILE * stream, const gsl_block_ushort * b); ++int gsl_block_ushort_fscanf (FILE * stream, gsl_block_ushort * b); ++int gsl_block_ushort_fprintf (FILE * stream, const gsl_block_ushort * b, const char *format); ++ ++int gsl_block_ushort_raw_fread (FILE * stream, unsigned short * b, const size_t n, const size_t stride); ++int gsl_block_ushort_raw_fwrite (FILE * stream, const unsigned short * b, const size_t n, const size_t stride); ++int gsl_block_ushort_raw_fscanf (FILE * stream, unsigned short * b, const size_t n, const size_t stride); ++int gsl_block_ushort_raw_fprintf (FILE * stream, const unsigned short * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_ushort_size (const gsl_block_ushort * b); ++unsigned short * gsl_block_ushort_data (const gsl_block_ushort * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h (revision 14078) +@@ -0,0 +1,126 @@ ++/* const/gsl_const_mks.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, ++ * 2006, 2007, 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST_MKS__ ++#define __GSL_CONST_MKS__ ++ ++#define GSL_CONST_MKS_SPEED_OF_LIGHT (2.99792458e8) /* m / s */ ++#define GSL_CONST_MKS_GRAVITATIONAL_CONSTANT (6.673e-11) /* m^3 / kg s^2 */ ++#define GSL_CONST_MKS_PLANCKS_CONSTANT_H (6.62606896e-34) /* kg m^2 / s */ ++#define GSL_CONST_MKS_PLANCKS_CONSTANT_HBAR (1.05457162825e-34) /* kg m^2 / s */ ++#define GSL_CONST_MKS_ASTRONOMICAL_UNIT (1.49597870691e11) /* m */ ++#define GSL_CONST_MKS_LIGHT_YEAR (9.46053620707e15) /* m */ ++#define GSL_CONST_MKS_PARSEC (3.08567758135e16) /* m */ ++#define GSL_CONST_MKS_GRAV_ACCEL (9.80665e0) /* m / s^2 */ ++#define GSL_CONST_MKS_ELECTRON_VOLT (1.602176487e-19) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_MASS_ELECTRON (9.10938188e-31) /* kg */ ++#define GSL_CONST_MKS_MASS_MUON (1.88353109e-28) /* kg */ ++#define GSL_CONST_MKS_MASS_PROTON (1.67262158e-27) /* kg */ ++#define GSL_CONST_MKS_MASS_NEUTRON (1.67492716e-27) /* kg */ ++#define GSL_CONST_MKS_RYDBERG (2.17987196968e-18) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_BOLTZMANN (1.3806504e-23) /* kg m^2 / K s^2 */ ++#define GSL_CONST_MKS_MOLAR_GAS (8.314472e0) /* kg m^2 / K mol s^2 */ ++#define GSL_CONST_MKS_STANDARD_GAS_VOLUME (2.2710981e-2) /* m^3 / mol */ ++#define GSL_CONST_MKS_MINUTE (6e1) /* s */ ++#define GSL_CONST_MKS_HOUR (3.6e3) /* s */ ++#define GSL_CONST_MKS_DAY (8.64e4) /* s */ ++#define GSL_CONST_MKS_WEEK (6.048e5) /* s */ ++#define GSL_CONST_MKS_INCH (2.54e-2) /* m */ ++#define GSL_CONST_MKS_FOOT (3.048e-1) /* m */ ++#define GSL_CONST_MKS_YARD (9.144e-1) /* m */ ++#define GSL_CONST_MKS_MILE (1.609344e3) /* m */ ++#define GSL_CONST_MKS_NAUTICAL_MILE (1.852e3) /* m */ ++#define GSL_CONST_MKS_FATHOM (1.8288e0) /* m */ ++#define GSL_CONST_MKS_MIL (2.54e-5) /* m */ ++#define GSL_CONST_MKS_POINT (3.52777777778e-4) /* m */ ++#define GSL_CONST_MKS_TEXPOINT (3.51459803515e-4) /* m */ ++#define GSL_CONST_MKS_MICRON (1e-6) /* m */ ++#define GSL_CONST_MKS_ANGSTROM (1e-10) /* m */ ++#define GSL_CONST_MKS_HECTARE (1e4) /* m^2 */ ++#define GSL_CONST_MKS_ACRE (4.04685642241e3) /* m^2 */ ++#define GSL_CONST_MKS_BARN (1e-28) /* m^2 */ ++#define GSL_CONST_MKS_LITER (1e-3) /* m^3 */ ++#define GSL_CONST_MKS_US_GALLON (3.78541178402e-3) /* m^3 */ ++#define GSL_CONST_MKS_QUART (9.46352946004e-4) /* m^3 */ ++#define GSL_CONST_MKS_PINT (4.73176473002e-4) /* m^3 */ ++#define GSL_CONST_MKS_CUP (2.36588236501e-4) /* m^3 */ ++#define GSL_CONST_MKS_FLUID_OUNCE (2.95735295626e-5) /* m^3 */ ++#define GSL_CONST_MKS_TABLESPOON (1.47867647813e-5) /* m^3 */ ++#define GSL_CONST_MKS_TEASPOON (4.92892159375e-6) /* m^3 */ ++#define GSL_CONST_MKS_CANADIAN_GALLON (4.54609e-3) /* m^3 */ ++#define GSL_CONST_MKS_UK_GALLON (4.546092e-3) /* m^3 */ ++#define GSL_CONST_MKS_MILES_PER_HOUR (4.4704e-1) /* m / s */ ++#define GSL_CONST_MKS_KILOMETERS_PER_HOUR (2.77777777778e-1) /* m / s */ ++#define GSL_CONST_MKS_KNOT (5.14444444444e-1) /* m / s */ ++#define GSL_CONST_MKS_POUND_MASS (4.5359237e-1) /* kg */ ++#define GSL_CONST_MKS_OUNCE_MASS (2.8349523125e-2) /* kg */ ++#define GSL_CONST_MKS_TON (9.0718474e2) /* kg */ ++#define GSL_CONST_MKS_METRIC_TON (1e3) /* kg */ ++#define GSL_CONST_MKS_UK_TON (1.0160469088e3) /* kg */ ++#define GSL_CONST_MKS_TROY_OUNCE (3.1103475e-2) /* kg */ ++#define GSL_CONST_MKS_CARAT (2e-4) /* kg */ ++#define GSL_CONST_MKS_UNIFIED_ATOMIC_MASS (1.660538782e-27) /* kg */ ++#define GSL_CONST_MKS_GRAM_FORCE (9.80665e-3) /* kg m / s^2 */ ++#define GSL_CONST_MKS_POUND_FORCE (4.44822161526e0) /* kg m / s^2 */ ++#define GSL_CONST_MKS_KILOPOUND_FORCE (4.44822161526e3) /* kg m / s^2 */ ++#define GSL_CONST_MKS_POUNDAL (1.38255e-1) /* kg m / s^2 */ ++#define GSL_CONST_MKS_CALORIE (4.1868e0) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_BTU (1.05505585262e3) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_THERM (1.05506e8) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_HORSEPOWER (7.457e2) /* kg m^2 / s^3 */ ++#define GSL_CONST_MKS_BAR (1e5) /* kg / m s^2 */ ++#define GSL_CONST_MKS_STD_ATMOSPHERE (1.01325e5) /* kg / m s^2 */ ++#define GSL_CONST_MKS_TORR (1.33322368421e2) /* kg / m s^2 */ ++#define GSL_CONST_MKS_METER_OF_MERCURY (1.33322368421e5) /* kg / m s^2 */ ++#define GSL_CONST_MKS_INCH_OF_MERCURY (3.38638815789e3) /* kg / m s^2 */ ++#define GSL_CONST_MKS_INCH_OF_WATER (2.490889e2) /* kg / m s^2 */ ++#define GSL_CONST_MKS_PSI (6.89475729317e3) /* kg / m s^2 */ ++#define GSL_CONST_MKS_POISE (1e-1) /* kg m^-1 s^-1 */ ++#define GSL_CONST_MKS_STOKES (1e-4) /* m^2 / s */ ++#define GSL_CONST_MKS_STILB (1e4) /* cd / m^2 */ ++#define GSL_CONST_MKS_LUMEN (1e0) /* cd sr */ ++#define GSL_CONST_MKS_LUX (1e0) /* cd sr / m^2 */ ++#define GSL_CONST_MKS_PHOT (1e4) /* cd sr / m^2 */ ++#define GSL_CONST_MKS_FOOTCANDLE (1.076e1) /* cd sr / m^2 */ ++#define GSL_CONST_MKS_LAMBERT (1e4) /* cd sr / m^2 */ ++#define GSL_CONST_MKS_FOOTLAMBERT (1.07639104e1) /* cd sr / m^2 */ ++#define GSL_CONST_MKS_CURIE (3.7e10) /* 1 / s */ ++#define GSL_CONST_MKS_ROENTGEN (2.58e-4) /* A s / kg */ ++#define GSL_CONST_MKS_RAD (1e-2) /* m^2 / s^2 */ ++#define GSL_CONST_MKS_SOLAR_MASS (1.98892e30) /* kg */ ++#define GSL_CONST_MKS_BOHR_RADIUS (5.291772083e-11) /* m */ ++#define GSL_CONST_MKS_NEWTON (1e0) /* kg m / s^2 */ ++#define GSL_CONST_MKS_DYNE (1e-5) /* kg m / s^2 */ ++#define GSL_CONST_MKS_JOULE (1e0) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_ERG (1e-7) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKS_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-8) /* kg / K^4 s^3 */ ++#define GSL_CONST_MKS_THOMSON_CROSS_SECTION (6.65245893699e-29) /* m^2 */ ++#define GSL_CONST_MKS_BOHR_MAGNETON (9.27400899e-24) /* A m^2 */ ++#define GSL_CONST_MKS_NUCLEAR_MAGNETON (5.05078317e-27) /* A m^2 */ ++#define GSL_CONST_MKS_ELECTRON_MAGNETIC_MOMENT (9.28476362e-24) /* A m^2 */ ++#define GSL_CONST_MKS_PROTON_MAGNETIC_MOMENT (1.410606633e-26) /* A m^2 */ ++#define GSL_CONST_MKS_FARADAY (9.64853429775e4) /* A s / mol */ ++#define GSL_CONST_MKS_ELECTRON_CHARGE (1.602176487e-19) /* A s */ ++#define GSL_CONST_MKS_VACUUM_PERMITTIVITY (8.854187817e-12) /* A^2 s^4 / kg m^3 */ ++#define GSL_CONST_MKS_VACUUM_PERMEABILITY (1.25663706144e-6) /* kg m / A^2 s^2 */ ++#define GSL_CONST_MKS_DEBYE (3.33564095198e-30) /* A s^2 / m^2 */ ++#define GSL_CONST_MKS_GAUSS (1e-4) /* kg / A s^2 */ ++ ++#endif /* __GSL_CONST_MKS__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h (revision 14078) +@@ -0,0 +1,224 @@ ++/* interpolation/gsl_interp.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman ++ */ ++#ifndef __GSL_INTERP_H__ ++#define __GSL_INTERP_H__ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* evaluation accelerator */ ++typedef struct { ++ size_t cache; /* cache of index */ ++ size_t miss_count; /* keep statistics */ ++ size_t hit_count; ++} ++gsl_interp_accel; ++ ++ ++/* interpolation object type */ ++typedef struct { ++ const char * name; ++ unsigned int min_size; ++ void * (*alloc) (size_t size); ++ int (*init) (void *, const double xa[], const double ya[], size_t size); ++ int (*eval) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y); ++ int (*eval_deriv) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_p); ++ int (*eval_deriv2) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_pp); ++ int (*eval_integ) (const void *, const double xa[], const double ya[], size_t size, gsl_interp_accel *, double a, double b, double * result); ++ void (*free) (void *); ++ ++} gsl_interp_type; ++ ++ ++/* general interpolation object */ ++typedef struct { ++ const gsl_interp_type * type; ++ double xmin; ++ double xmax; ++ size_t size; ++ void * state; ++} gsl_interp; ++ ++ ++/* available types */ ++GSL_VAR const gsl_interp_type * gsl_interp_linear; ++GSL_VAR const gsl_interp_type * gsl_interp_polynomial; ++GSL_VAR const gsl_interp_type * gsl_interp_cspline; ++GSL_VAR const gsl_interp_type * gsl_interp_cspline_periodic; ++GSL_VAR const gsl_interp_type * gsl_interp_akima; ++GSL_VAR const gsl_interp_type * gsl_interp_akima_periodic; ++ ++gsl_interp_accel * ++gsl_interp_accel_alloc(void); ++ ++int ++gsl_interp_accel_reset (gsl_interp_accel * a); ++ ++void ++gsl_interp_accel_free(gsl_interp_accel * a); ++ ++gsl_interp * ++gsl_interp_alloc(const gsl_interp_type * T, size_t n); ++ ++int ++gsl_interp_init(gsl_interp * obj, const double xa[], const double ya[], size_t size); ++ ++const char * gsl_interp_name(const gsl_interp * interp); ++unsigned int gsl_interp_min_size(const gsl_interp * interp); ++unsigned int gsl_interp_type_min_size(const gsl_interp_type * T); ++ ++ ++int ++gsl_interp_eval_e(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a, double * y); ++ ++double ++gsl_interp_eval(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a); ++ ++int ++gsl_interp_eval_deriv_e(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a, ++ double * d); ++ ++double ++gsl_interp_eval_deriv(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a); ++ ++int ++gsl_interp_eval_deriv2_e(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a, ++ double * d2); ++ ++double ++gsl_interp_eval_deriv2(const gsl_interp * obj, ++ const double xa[], const double ya[], double x, ++ gsl_interp_accel * a); ++ ++int ++gsl_interp_eval_integ_e(const gsl_interp * obj, ++ const double xa[], const double ya[], ++ double a, double b, ++ gsl_interp_accel * acc, ++ double * result); ++ ++double ++gsl_interp_eval_integ(const gsl_interp * obj, ++ const double xa[], const double ya[], ++ double a, double b, ++ gsl_interp_accel * acc); ++ ++void ++gsl_interp_free(gsl_interp * interp); ++ ++INLINE_DECL size_t ++gsl_interp_bsearch(const double x_array[], double x, ++ size_t index_lo, size_t index_hi); ++ ++#ifdef HAVE_INLINE ++ ++/* Perform a binary search of an array of values. ++ * ++ * The parameters index_lo and index_hi provide an initial bracket, ++ * and it is assumed that index_lo < index_hi. The resulting index ++ * is guaranteed to be strictly less than index_hi and greater than ++ * or equal to index_lo, so that the implicit bracket [index, index+1] ++ * always corresponds to a region within the implicit value range of ++ * the value array. ++ * ++ * Note that this means the relationship of 'x' to x_array[index] ++ * and x_array[index+1] depends on the result region, i.e. the ++ * behaviour at the boundaries may not correspond to what you ++ * expect. We have the following complete specification of the ++ * behaviour. ++ * Suppose the input is x_array[] = { x0, x1, ..., xN } ++ * if ( x == x0 ) then index == 0 ++ * if ( x > x0 && x <= x1 ) then index == 0, and sim. for other interior pts ++ * if ( x == xN ) then index == N-1 ++ * if ( x > xN ) then index == N-1 ++ * if ( x < x0 ) then index == 0 ++ */ ++ ++INLINE_FUN size_t ++gsl_interp_bsearch(const double x_array[], double x, ++ size_t index_lo, size_t index_hi) ++{ ++ size_t ilo = index_lo; ++ size_t ihi = index_hi; ++ while(ihi > ilo + 1) { ++ size_t i = (ihi + ilo)/2; ++ if(x_array[i] > x) ++ ihi = i; ++ else ++ ilo = i; ++ } ++ ++ return ilo; ++} ++#endif ++ ++INLINE_DECL size_t ++gsl_interp_accel_find(gsl_interp_accel * a, const double x_array[], size_t size, double x); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN size_t ++gsl_interp_accel_find(gsl_interp_accel * a, const double xa[], size_t len, double x) ++{ ++ size_t x_index = a->cache; ++ ++ if(x < xa[x_index]) { ++ a->miss_count++; ++ a->cache = gsl_interp_bsearch(xa, x, 0, x_index); ++ } ++ else if(x >= xa[x_index + 1]) { ++ a->miss_count++; ++ a->cache = gsl_interp_bsearch(xa, x, x_index, len-1); ++ } ++ else { ++ a->hit_count++; ++ } ++ ++ return a->cache; ++} ++#endif /* HAVE_INLINE */ ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_INTERP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_LONG_DOUBLE_H__ ++#define __GSL_BLOCK_LONG_DOUBLE_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_long_double_struct ++{ ++ size_t size; ++ long double *data; ++}; ++ ++typedef struct gsl_block_long_double_struct gsl_block_long_double; ++ ++gsl_block_long_double *gsl_block_long_double_alloc (const size_t n); ++gsl_block_long_double *gsl_block_long_double_calloc (const size_t n); ++void gsl_block_long_double_free (gsl_block_long_double * b); ++ ++int gsl_block_long_double_fread (FILE * stream, gsl_block_long_double * b); ++int gsl_block_long_double_fwrite (FILE * stream, const gsl_block_long_double * b); ++int gsl_block_long_double_fscanf (FILE * stream, gsl_block_long_double * b); ++int gsl_block_long_double_fprintf (FILE * stream, const gsl_block_long_double * b, const char *format); ++ ++int gsl_block_long_double_raw_fread (FILE * stream, long double * b, const size_t n, const size_t stride); ++int gsl_block_long_double_raw_fwrite (FILE * stream, const long double * b, const size_t n, const size_t stride); ++int gsl_block_long_double_raw_fscanf (FILE * stream, long double * b, const size_t n, const size_t stride); ++int gsl_block_long_double_raw_fprintf (FILE * stream, const long double * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_long_double_size (const gsl_block_long_double * b); ++long double * gsl_block_long_double_data (const gsl_block_long_double * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h (revision 14078) +@@ -0,0 +1,91 @@ ++/* specfunc/gsl_sf_erf.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_ERF_H__ ++#define __GSL_SF_ERF_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Complementary Error Function ++ * erfc(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,x,Infinity}] ++ * ++ * exceptions: none ++ */ ++int gsl_sf_erfc_e(double x, gsl_sf_result * result); ++double gsl_sf_erfc(double x); ++ ++ ++/* Log Complementary Error Function ++ * ++ * exceptions: none ++ */ ++int gsl_sf_log_erfc_e(double x, gsl_sf_result * result); ++double gsl_sf_log_erfc(double x); ++ ++ ++/* Error Function ++ * erf(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,0,x}] ++ * ++ * exceptions: none ++ */ ++int gsl_sf_erf_e(double x, gsl_sf_result * result); ++double gsl_sf_erf(double x); ++ ++ ++/* Probability functions: ++ * Z(x) : Abramowitz+Stegun 26.2.1 ++ * Q(x) : Abramowitz+Stegun 26.2.3 ++ * ++ * exceptions: none ++ */ ++int gsl_sf_erf_Z_e(double x, gsl_sf_result * result); ++int gsl_sf_erf_Q_e(double x, gsl_sf_result * result); ++double gsl_sf_erf_Z(double x); ++double gsl_sf_erf_Q(double x); ++ ++ ++/* Hazard function, also known as the inverse Mill's ratio. ++ * ++ * H(x) := Z(x)/Q(x) ++ * = Sqrt[2/Pi] Exp[-x^2 / 2] / Erfc[x/Sqrt[2]] ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_hazard_e(double x, gsl_sf_result * result); ++double gsl_sf_hazard(double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_ERF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h (revision 14078) +@@ -0,0 +1,82 @@ ++/* siman/gsl_siman.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Mark Galassi ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SIMAN_H__ ++#define __GSL_SIMAN_H__ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* types for the function pointers passed to gsl_siman_solve */ ++ ++typedef double (*gsl_siman_Efunc_t) (void *xp); ++typedef void (*gsl_siman_step_t) (const gsl_rng *r, void *xp, double step_size); ++typedef double (*gsl_siman_metric_t) (void *xp, void *yp); ++typedef void (*gsl_siman_print_t) (void *xp); ++typedef void (*gsl_siman_copy_t) (void *source, void *dest); ++typedef void * (*gsl_siman_copy_construct_t) (void *xp); ++typedef void (*gsl_siman_destroy_t) (void *xp); ++ ++/* this structure contains all the information needed to structure the ++ search, beyond the energy function, the step function and the ++ initial guess. */ ++ ++typedef struct { ++ int n_tries; /* how many points to try for each step */ ++ int iters_fixed_T; /* how many iterations at each temperature? */ ++ double step_size; /* max step size in the random walk */ ++ /* the following parameters are for the Boltzmann distribution */ ++ double k, t_initial, mu_t, t_min; ++} gsl_siman_params_t; ++ ++/* prototype for the workhorse function */ ++ ++void gsl_siman_solve(const gsl_rng * r, ++ void *x0_p, gsl_siman_Efunc_t Ef, ++ gsl_siman_step_t take_step, ++ gsl_siman_metric_t distance, ++ gsl_siman_print_t print_position, ++ gsl_siman_copy_t copyfunc, ++ gsl_siman_copy_construct_t copy_constructor, ++ gsl_siman_destroy_t destructor, ++ size_t element_size, ++ gsl_siman_params_t params); ++ ++void ++gsl_siman_solve_many (const gsl_rng * r, void *x0_p, gsl_siman_Efunc_t Ef, ++ gsl_siman_step_t take_step, ++ gsl_siman_metric_t distance, ++ gsl_siman_print_t print_position, ++ size_t element_size, ++ gsl_siman_params_t params); ++ ++__END_DECLS ++ ++#endif /* __GSL_SIMAN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h (revision 14078) +@@ -0,0 +1,49 @@ ++/* specfunc/gsl_sf_pow_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_POW_INT_H__ ++#define __GSL_SF_POW_INT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Calculate x^n. ++ * Does not check for overflow/underflow. ++ */ ++int gsl_sf_pow_int_e(double x, int n, gsl_sf_result * result); ++double gsl_sf_pow_int(const double x, const int n); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h (revision 14078) +@@ -0,0 +1,82 @@ ++/* histogram/ntuple.h ++ * ++ * Copyright (C) 2000 Simone Piccardi ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ * ++ */ ++ ++/* Jan/2001 Modified by Brian Gough. Minor changes for GSL */ ++ ++#ifndef __GSL_NTUPLE_H__ ++#define __GSL_NTUPLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ FILE * file; ++ void * ntuple_data; ++ size_t size; ++} gsl_ntuple; ++ ++typedef struct { ++ int (* function) (void * ntuple_data, void * params); ++ void * params; ++} gsl_ntuple_select_fn; ++ ++typedef struct { ++ double (* function) (void * ntuple_data, void * params); ++ void * params; ++} gsl_ntuple_value_fn; ++ ++gsl_ntuple * ++gsl_ntuple_open (char * filename, void * ntuple_data, size_t size); ++ ++gsl_ntuple * ++gsl_ntuple_create (char * filename, void * ntuple_data, size_t size); ++ ++int gsl_ntuple_write (gsl_ntuple * ntuple); ++int gsl_ntuple_read (gsl_ntuple * ntuple); ++ ++int gsl_ntuple_bookdata (gsl_ntuple * ntuple); /* synonym for write */ ++ ++int gsl_ntuple_project (gsl_histogram * h, gsl_ntuple * ntuple, ++ gsl_ntuple_value_fn *value_func, ++ gsl_ntuple_select_fn *select_func); ++ ++int gsl_ntuple_close (gsl_ntuple * ntuple); ++ ++__END_DECLS ++ ++#endif /* __GSL_NTUPLE_H__ */ ++ ++ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_USHORT_H__ ++#define __GSL_PERMUTE_VECTOR_USHORT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_ushort (const gsl_permutation * p, gsl_vector_ushort * v); ++int gsl_permute_vector_ushort_inverse (const gsl_permutation * p, gsl_vector_ushort * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h (revision 14078) +@@ -0,0 +1,112 @@ ++/* specfunc/gsl_sf_ellint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_ELLINT_H__ ++#define __GSL_SF_ELLINT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Legendre form of complete elliptic integrals ++ * ++ * K(k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}] ++ * E(k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}] ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_ellint_Kcomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_Kcomp(double k, gsl_mode_t mode); ++ ++int gsl_sf_ellint_Ecomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_Ecomp(double k, gsl_mode_t mode); ++ ++int gsl_sf_ellint_Pcomp_e(double k, double n, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_Pcomp(double k, double n, gsl_mode_t mode); ++ ++int gsl_sf_ellint_Dcomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_Dcomp(double k, gsl_mode_t mode); ++ ++ ++/* Legendre form of incomplete elliptic integrals ++ * ++ * F(phi,k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] ++ * E(phi,k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] ++ * P(phi,k,n) = Integral[(1 + n Sin[t]^2)^(-1)/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] ++ * D(phi,k,n) = R_D(1-Sin[phi]^2, 1-k^2 Sin[phi]^2, 1.0) ++ * ++ * F: [Carlson, Numerische Mathematik 33 (1979) 1, (4.1)] ++ * E: [Carlson, ", (4.2)] ++ * P: [Carlson, ", (4.3)] ++ * D: [Carlson, ", (4.4)] ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_ellint_F_e(double phi, double k, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_F(double phi, double k, gsl_mode_t mode); ++ ++int gsl_sf_ellint_E_e(double phi, double k, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_E(double phi, double k, gsl_mode_t mode); ++ ++int gsl_sf_ellint_P_e(double phi, double k, double n, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_P(double phi, double k, double n, gsl_mode_t mode); ++ ++int gsl_sf_ellint_D_e(double phi, double k, double n, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_D(double phi, double k, double n, gsl_mode_t mode); ++ ++ ++/* Carlson's symmetric basis of functions ++ * ++ * RC(x,y) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1)], {t,0,Inf}] ++ * RD(x,y,z) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-3/2), {t,0,Inf}] ++ * RF(x,y,z) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2), {t,0,Inf}] ++ * RJ(x,y,z,p) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2) (t+p)^(-1), {t,0,Inf}] ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_ellint_RC_e(double x, double y, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_RC(double x, double y, gsl_mode_t mode); ++ ++int gsl_sf_ellint_RD_e(double x, double y, double z, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_RD(double x, double y, double z, gsl_mode_t mode); ++ ++int gsl_sf_ellint_RF_e(double x, double y, double z, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_RF(double x, double y, double z, gsl_mode_t mode); ++ ++int gsl_sf_ellint_RJ_e(double x, double y, double z, double p, gsl_mode_t mode, gsl_sf_result * result); ++double gsl_sf_ellint_RJ(double x, double y, double z, double p, gsl_mode_t mode); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_ELLINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h (revision 14078) +@@ -0,0 +1,91 @@ ++/* specfunc/gsl_sf_debye.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++/* augmented by D_5(x) and D_6(x) by Richard J. Mathar, 2005-11-08 */ ++ ++#ifndef __GSL_SF_DEBYE_H__ ++#define __GSL_SF_DEBYE_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] */ ++ ++/* D_1(x) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_debye_1_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_1(const double x); ++ ++ ++/* D_2(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_debye_2_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_2(const double x); ++ ++ ++/* D_3(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_debye_3_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_3(const double x); ++ ++ ++/* D_4(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_debye_4_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_4(const double x); ++ ++/* D_5(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_debye_5_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_5(const double x); ++ ++/* D_6(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_debye_6_e(const double x, gsl_sf_result * result); ++double gsl_sf_debye_6(const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_DEBYE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h (revision 14078) +@@ -0,0 +1,351 @@ ++/* matrix/gsl_matrix_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_COMPLEX_FLOAT_H__ ++#define __GSL_MATRIX_COMPLEX_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ float * data; ++ gsl_block_complex_float * block; ++ int owner; ++} gsl_matrix_complex_float ; ++ ++typedef struct ++{ ++ gsl_matrix_complex_float matrix; ++} _gsl_matrix_complex_float_view; ++ ++typedef _gsl_matrix_complex_float_view gsl_matrix_complex_float_view; ++ ++typedef struct ++{ ++ gsl_matrix_complex_float matrix; ++} _gsl_matrix_complex_float_const_view; ++ ++typedef const _gsl_matrix_complex_float_const_view gsl_matrix_complex_float_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_matrix_complex_float * ++gsl_matrix_complex_float_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex_float * ++gsl_matrix_complex_float_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex_float * ++gsl_matrix_complex_float_alloc_from_block (gsl_block_complex_float * b, ++ const size_t offset, ++ const size_t n1, const size_t n2, const size_t d2); ++ ++gsl_matrix_complex_float * ++gsl_matrix_complex_float_alloc_from_matrix (gsl_matrix_complex_float * b, ++ const size_t k1, const size_t k2, ++ const size_t n1, const size_t n2); ++ ++gsl_vector_complex_float * ++gsl_vector_complex_float_alloc_row_from_matrix (gsl_matrix_complex_float * m, ++ const size_t i); ++ ++gsl_vector_complex_float * ++gsl_vector_complex_float_alloc_col_from_matrix (gsl_matrix_complex_float * m, ++ const size_t j); ++ ++void gsl_matrix_complex_float_free (gsl_matrix_complex_float * m); ++ ++/* Views */ ++ ++_gsl_matrix_complex_float_view ++gsl_matrix_complex_float_submatrix (gsl_matrix_complex_float * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_row (gsl_matrix_complex_float * m, const size_t i); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_column (gsl_matrix_complex_float * m, const size_t j); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_diagonal (gsl_matrix_complex_float * m); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_subdiagonal (gsl_matrix_complex_float * m, const size_t k); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_superdiagonal (gsl_matrix_complex_float * m, const size_t k); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_subrow (gsl_matrix_complex_float * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_float_view ++gsl_matrix_complex_float_subcolumn (gsl_matrix_complex_float * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_float_view ++gsl_matrix_complex_float_view_array (float * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_float_view ++gsl_matrix_complex_float_view_array_with_tda (float * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_float_view ++gsl_matrix_complex_float_view_vector (gsl_vector_complex_float * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_float_view ++gsl_matrix_complex_float_view_vector_with_tda (gsl_vector_complex_float * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_complex_float_const_view ++gsl_matrix_complex_float_const_submatrix (const gsl_matrix_complex_float * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_row (const gsl_matrix_complex_float * m, ++ const size_t i); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_column (const gsl_matrix_complex_float * m, ++ const size_t j); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_diagonal (const gsl_matrix_complex_float * m); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_subdiagonal (const gsl_matrix_complex_float * m, ++ const size_t k); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_superdiagonal (const gsl_matrix_complex_float * m, ++ const size_t k); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_subrow (const gsl_matrix_complex_float * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_float_const_view ++gsl_matrix_complex_float_const_subcolumn (const gsl_matrix_complex_float * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_float_const_view ++gsl_matrix_complex_float_const_view_array (const float * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_float_const_view ++gsl_matrix_complex_float_const_view_array_with_tda (const float * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_float_const_view ++gsl_matrix_complex_float_const_view_vector (const gsl_vector_complex_float * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_float_const_view ++gsl_matrix_complex_float_const_view_vector_with_tda (const gsl_vector_complex_float * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_complex_float_set_zero (gsl_matrix_complex_float * m); ++void gsl_matrix_complex_float_set_identity (gsl_matrix_complex_float * m); ++void gsl_matrix_complex_float_set_all (gsl_matrix_complex_float * m, gsl_complex_float x); ++ ++int gsl_matrix_complex_float_fread (FILE * stream, gsl_matrix_complex_float * m) ; ++int gsl_matrix_complex_float_fwrite (FILE * stream, const gsl_matrix_complex_float * m) ; ++int gsl_matrix_complex_float_fscanf (FILE * stream, gsl_matrix_complex_float * m); ++int gsl_matrix_complex_float_fprintf (FILE * stream, const gsl_matrix_complex_float * m, const char * format); ++ ++int gsl_matrix_complex_float_memcpy(gsl_matrix_complex_float * dest, const gsl_matrix_complex_float * src); ++int gsl_matrix_complex_float_swap(gsl_matrix_complex_float * m1, gsl_matrix_complex_float * m2); ++ ++int gsl_matrix_complex_float_swap_rows(gsl_matrix_complex_float * m, const size_t i, const size_t j); ++int gsl_matrix_complex_float_swap_columns(gsl_matrix_complex_float * m, const size_t i, const size_t j); ++int gsl_matrix_complex_float_swap_rowcol(gsl_matrix_complex_float * m, const size_t i, const size_t j); ++ ++int gsl_matrix_complex_float_transpose (gsl_matrix_complex_float * m); ++int gsl_matrix_complex_float_transpose_memcpy (gsl_matrix_complex_float * dest, const gsl_matrix_complex_float * src); ++ ++int gsl_matrix_complex_float_equal (const gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); ++ ++int gsl_matrix_complex_float_isnull (const gsl_matrix_complex_float * m); ++int gsl_matrix_complex_float_ispos (const gsl_matrix_complex_float * m); ++int gsl_matrix_complex_float_isneg (const gsl_matrix_complex_float * m); ++int gsl_matrix_complex_float_isnonneg (const gsl_matrix_complex_float * m); ++ ++int gsl_matrix_complex_float_add (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); ++int gsl_matrix_complex_float_sub (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); ++int gsl_matrix_complex_float_mul_elements (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); ++int gsl_matrix_complex_float_div_elements (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); ++int gsl_matrix_complex_float_scale (gsl_matrix_complex_float * a, const gsl_complex_float x); ++int gsl_matrix_complex_float_add_constant (gsl_matrix_complex_float * a, const gsl_complex_float x); ++int gsl_matrix_complex_float_add_diagonal (gsl_matrix_complex_float * a, const gsl_complex_float x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_complex_float_get_row(gsl_vector_complex_float * v, const gsl_matrix_complex_float * m, const size_t i); ++int gsl_matrix_complex_float_get_col(gsl_vector_complex_float * v, const gsl_matrix_complex_float * m, const size_t j); ++int gsl_matrix_complex_float_set_row(gsl_matrix_complex_float * m, const size_t i, const gsl_vector_complex_float * v); ++int gsl_matrix_complex_float_set_col(gsl_matrix_complex_float * m, const size_t j, const gsl_vector_complex_float * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL gsl_complex_float gsl_matrix_complex_float_get(const gsl_matrix_complex_float * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_complex_float_set(gsl_matrix_complex_float * m, const size_t i, const size_t j, const gsl_complex_float x); ++ ++INLINE_DECL gsl_complex_float * gsl_matrix_complex_float_ptr(gsl_matrix_complex_float * m, const size_t i, const size_t j); ++INLINE_DECL const gsl_complex_float * gsl_matrix_complex_float_const_ptr(const gsl_matrix_complex_float * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex_float ++gsl_matrix_complex_float_get(const gsl_matrix_complex_float * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ gsl_complex_float zero = {{0,0}}; ++ ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; ++ } ++ } ++#endif ++ return *(gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_complex_float_set(gsl_matrix_complex_float * m, ++ const size_t i, const size_t j, const gsl_complex_float x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ *(gsl_complex_float *)(m->data + 2*(i * m->tda + j)) = x ; ++} ++ ++INLINE_FUN ++gsl_complex_float * ++gsl_matrix_complex_float_ptr(gsl_matrix_complex_float * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const gsl_complex_float * ++gsl_matrix_complex_float_const_ptr(const gsl_matrix_complex_float * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_complex_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ ++#define __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_complex_long_double (const size_t * p, long double * data, const size_t stride, const size_t n); ++int gsl_permute_complex_long_double_inverse (const size_t * p, long double * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h (revision 14078) +@@ -0,0 +1,602 @@ ++/* blas/gsl_blas.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* ++ * Author: G. Jungman ++ */ ++#ifndef __GSL_BLAS_H__ ++#define __GSL_BLAS_H__ ++ ++#include ++#include ++ ++#include ++ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* ======================================================================== ++ * Level 1 ++ * ======================================================================== ++ */ ++ ++int gsl_blas_sdsdot (float alpha, ++ const gsl_vector_float * X, ++ const gsl_vector_float * Y, ++ float * result ++ ); ++ ++int gsl_blas_dsdot (const gsl_vector_float * X, ++ const gsl_vector_float * Y, ++ double * result ++ ); ++ ++int gsl_blas_sdot (const gsl_vector_float * X, ++ const gsl_vector_float * Y, ++ float * result ++ ); ++ ++int gsl_blas_ddot (const gsl_vector * X, ++ const gsl_vector * Y, ++ double * result ++ ); ++ ++ ++int gsl_blas_cdotu (const gsl_vector_complex_float * X, ++ const gsl_vector_complex_float * Y, ++ gsl_complex_float * dotu); ++ ++int gsl_blas_cdotc (const gsl_vector_complex_float * X, ++ const gsl_vector_complex_float * Y, ++ gsl_complex_float * dotc); ++ ++int gsl_blas_zdotu (const gsl_vector_complex * X, ++ const gsl_vector_complex * Y, ++ gsl_complex * dotu); ++ ++int gsl_blas_zdotc (const gsl_vector_complex * X, ++ const gsl_vector_complex * Y, ++ gsl_complex * dotc); ++ ++ ++float gsl_blas_snrm2 (const gsl_vector_float * X); ++float gsl_blas_sasum (const gsl_vector_float * X); ++double gsl_blas_dnrm2 (const gsl_vector * X); ++double gsl_blas_dasum (const gsl_vector * X); ++float gsl_blas_scnrm2 (const gsl_vector_complex_float * X); ++float gsl_blas_scasum (const gsl_vector_complex_float * X); ++double gsl_blas_dznrm2 (const gsl_vector_complex * X); ++double gsl_blas_dzasum (const gsl_vector_complex * X); ++ ++ ++CBLAS_INDEX_t gsl_blas_isamax (const gsl_vector_float * X); ++CBLAS_INDEX_t gsl_blas_idamax (const gsl_vector * X); ++CBLAS_INDEX_t gsl_blas_icamax (const gsl_vector_complex_float * X); ++CBLAS_INDEX_t gsl_blas_izamax (const gsl_vector_complex * X); ++ ++ ++int gsl_blas_sswap (gsl_vector_float * X, ++ gsl_vector_float * Y); ++ ++int gsl_blas_scopy (const gsl_vector_float * X, ++ gsl_vector_float * Y); ++ ++int gsl_blas_saxpy (float alpha, ++ const gsl_vector_float * X, ++ gsl_vector_float * Y); ++ ++int gsl_blas_dswap (gsl_vector * X, ++ gsl_vector * Y); ++ ++int gsl_blas_dcopy (const gsl_vector * X, ++ gsl_vector * Y); ++ ++int gsl_blas_daxpy (double alpha, ++ const gsl_vector * X, ++ gsl_vector * Y); ++ ++int gsl_blas_cswap (gsl_vector_complex_float * X, ++ gsl_vector_complex_float * Y); ++ ++int gsl_blas_ccopy (const gsl_vector_complex_float * X, ++ gsl_vector_complex_float * Y); ++ ++int gsl_blas_caxpy (const gsl_complex_float alpha, ++ const gsl_vector_complex_float * X, ++ gsl_vector_complex_float * Y); ++ ++int gsl_blas_zswap (gsl_vector_complex * X, ++ gsl_vector_complex * Y); ++ ++int gsl_blas_zcopy (const gsl_vector_complex * X, ++ gsl_vector_complex * Y); ++ ++int gsl_blas_zaxpy (const gsl_complex alpha, ++ const gsl_vector_complex * X, ++ gsl_vector_complex * Y); ++ ++ ++int gsl_blas_srotg (float a[], float b[], float c[], float s[]); ++ ++int gsl_blas_srotmg (float d1[], float d2[], float b1[], float b2, float P[]); ++ ++int gsl_blas_srot (gsl_vector_float * X, ++ gsl_vector_float * Y, ++ float c, float s); ++ ++int gsl_blas_srotm (gsl_vector_float * X, ++ gsl_vector_float * Y, ++ const float P[]); ++ ++int gsl_blas_drotg (double a[], double b[], double c[], double s[]); ++ ++int gsl_blas_drotmg (double d1[], double d2[], double b1[], ++ double b2, double P[]); ++ ++int gsl_blas_drot (gsl_vector * X, ++ gsl_vector * Y, ++ const double c, const double s); ++ ++int gsl_blas_drotm (gsl_vector * X, ++ gsl_vector * Y, ++ const double P[]); ++ ++ ++void gsl_blas_sscal (float alpha, gsl_vector_float * X); ++void gsl_blas_dscal (double alpha, gsl_vector * X); ++void gsl_blas_cscal (const gsl_complex_float alpha, gsl_vector_complex_float * X); ++void gsl_blas_zscal (const gsl_complex alpha, gsl_vector_complex * X); ++void gsl_blas_csscal (float alpha, gsl_vector_complex_float * X); ++void gsl_blas_zdscal (double alpha, gsl_vector_complex * X); ++ ++ ++/* =========================================================================== ++ * Level 2 ++ * =========================================================================== ++ */ ++ ++/* ++ * Routines with standard 4 prefixes (S, D, C, Z) ++ */ ++int gsl_blas_sgemv (CBLAS_TRANSPOSE_t TransA, ++ float alpha, ++ const gsl_matrix_float * A, ++ const gsl_vector_float * X, ++ float beta, ++ gsl_vector_float * Y); ++ ++int gsl_blas_strmv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_float * A, ++ gsl_vector_float * X); ++ ++int gsl_blas_strsv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_float * A, ++ gsl_vector_float * X); ++ ++int gsl_blas_dgemv (CBLAS_TRANSPOSE_t TransA, ++ double alpha, ++ const gsl_matrix * A, ++ const gsl_vector * X, ++ double beta, ++ gsl_vector * Y); ++ ++int gsl_blas_dtrmv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix * A, ++ gsl_vector * X); ++ ++int gsl_blas_dtrsv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix * A, ++ gsl_vector * X); ++ ++int gsl_blas_cgemv (CBLAS_TRANSPOSE_t TransA, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_vector_complex_float * X, ++ const gsl_complex_float beta, ++ gsl_vector_complex_float * Y); ++ ++int gsl_blas_ctrmv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_complex_float * A, ++ gsl_vector_complex_float * X); ++ ++int gsl_blas_ctrsv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_complex_float * A, ++ gsl_vector_complex_float * X); ++ ++int gsl_blas_zgemv (CBLAS_TRANSPOSE_t TransA, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_vector_complex * X, ++ const gsl_complex beta, ++ gsl_vector_complex * Y); ++ ++int gsl_blas_ztrmv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_complex * A, ++ gsl_vector_complex * X); ++ ++int gsl_blas_ztrsv (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, ++ const gsl_matrix_complex * A, ++ gsl_vector_complex *X); ++ ++/* ++ * Routines with S and D prefixes only ++ */ ++int gsl_blas_ssymv (CBLAS_UPLO_t Uplo, ++ float alpha, ++ const gsl_matrix_float * A, ++ const gsl_vector_float * X, ++ float beta, ++ gsl_vector_float * Y); ++ ++int gsl_blas_sger (float alpha, ++ const gsl_vector_float * X, ++ const gsl_vector_float * Y, ++ gsl_matrix_float * A); ++ ++int gsl_blas_ssyr (CBLAS_UPLO_t Uplo, ++ float alpha, ++ const gsl_vector_float * X, ++ gsl_matrix_float * A); ++ ++int gsl_blas_ssyr2 (CBLAS_UPLO_t Uplo, ++ float alpha, ++ const gsl_vector_float * X, ++ const gsl_vector_float * Y, ++ gsl_matrix_float * A); ++ ++int gsl_blas_dsymv (CBLAS_UPLO_t Uplo, ++ double alpha, ++ const gsl_matrix * A, ++ const gsl_vector * X, ++ double beta, ++ gsl_vector * Y); ++int gsl_blas_dger (double alpha, ++ const gsl_vector * X, ++ const gsl_vector * Y, ++ gsl_matrix * A); ++ ++int gsl_blas_dsyr (CBLAS_UPLO_t Uplo, ++ double alpha, ++ const gsl_vector * X, ++ gsl_matrix * A); ++ ++int gsl_blas_dsyr2 (CBLAS_UPLO_t Uplo, ++ double alpha, ++ const gsl_vector * X, ++ const gsl_vector * Y, ++ gsl_matrix * A); ++ ++/* ++ * Routines with C and Z prefixes only ++ */ ++ ++int gsl_blas_chemv (CBLAS_UPLO_t Uplo, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_vector_complex_float * X, ++ const gsl_complex_float beta, ++ gsl_vector_complex_float * Y); ++ ++int gsl_blas_cgeru (const gsl_complex_float alpha, ++ const gsl_vector_complex_float * X, ++ const gsl_vector_complex_float * Y, ++ gsl_matrix_complex_float * A); ++ ++int gsl_blas_cgerc (const gsl_complex_float alpha, ++ const gsl_vector_complex_float * X, ++ const gsl_vector_complex_float * Y, ++ gsl_matrix_complex_float * A); ++ ++int gsl_blas_cher (CBLAS_UPLO_t Uplo, ++ float alpha, ++ const gsl_vector_complex_float * X, ++ gsl_matrix_complex_float * A); ++ ++int gsl_blas_cher2 (CBLAS_UPLO_t Uplo, ++ const gsl_complex_float alpha, ++ const gsl_vector_complex_float * X, ++ const gsl_vector_complex_float * Y, ++ gsl_matrix_complex_float * A); ++ ++int gsl_blas_zhemv (CBLAS_UPLO_t Uplo, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_vector_complex * X, ++ const gsl_complex beta, ++ gsl_vector_complex * Y); ++ ++int gsl_blas_zgeru (const gsl_complex alpha, ++ const gsl_vector_complex * X, ++ const gsl_vector_complex * Y, ++ gsl_matrix_complex * A); ++ ++int gsl_blas_zgerc (const gsl_complex alpha, ++ const gsl_vector_complex * X, ++ const gsl_vector_complex * Y, ++ gsl_matrix_complex * A); ++ ++int gsl_blas_zher (CBLAS_UPLO_t Uplo, ++ double alpha, ++ const gsl_vector_complex * X, ++ gsl_matrix_complex * A); ++ ++int gsl_blas_zher2 (CBLAS_UPLO_t Uplo, ++ const gsl_complex alpha, ++ const gsl_vector_complex * X, ++ const gsl_vector_complex * Y, ++ gsl_matrix_complex * A); ++ ++/* ++ * =========================================================================== ++ * Prototypes for level 3 BLAS ++ * =========================================================================== ++ */ ++ ++/* ++ * Routines with standard 4 prefixes (S, D, C, Z) ++ */ ++int gsl_blas_sgemm (CBLAS_TRANSPOSE_t TransA, ++ CBLAS_TRANSPOSE_t TransB, ++ float alpha, ++ const gsl_matrix_float * A, ++ const gsl_matrix_float * B, ++ float beta, ++ gsl_matrix_float * C); ++ ++int gsl_blas_ssymm (CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, ++ float alpha, ++ const gsl_matrix_float * A, ++ const gsl_matrix_float * B, ++ float beta, ++ gsl_matrix_float * C); ++ ++int gsl_blas_ssyrk (CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, ++ float alpha, ++ const gsl_matrix_float * A, ++ float beta, ++ gsl_matrix_float * C); ++ ++int gsl_blas_ssyr2k (CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, ++ float alpha, ++ const gsl_matrix_float * A, ++ const gsl_matrix_float * B, ++ float beta, ++ gsl_matrix_float * C); ++ ++int gsl_blas_strmm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ float alpha, ++ const gsl_matrix_float * A, ++ gsl_matrix_float * B); ++ ++int gsl_blas_strsm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ float alpha, ++ const gsl_matrix_float * A, ++ gsl_matrix_float * B); ++ ++int gsl_blas_dgemm (CBLAS_TRANSPOSE_t TransA, ++ CBLAS_TRANSPOSE_t TransB, ++ double alpha, ++ const gsl_matrix * A, ++ const gsl_matrix * B, ++ double beta, ++ gsl_matrix * C); ++ ++int gsl_blas_dsymm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, ++ double alpha, ++ const gsl_matrix * A, ++ const gsl_matrix * B, ++ double beta, ++ gsl_matrix * C); ++ ++int gsl_blas_dsyrk (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ double alpha, ++ const gsl_matrix * A, ++ double beta, ++ gsl_matrix * C); ++ ++int gsl_blas_dsyr2k (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ double alpha, ++ const gsl_matrix * A, ++ const gsl_matrix * B, ++ double beta, ++ gsl_matrix * C); ++ ++int gsl_blas_dtrmm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ double alpha, ++ const gsl_matrix * A, ++ gsl_matrix * B); ++ ++int gsl_blas_dtrsm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ double alpha, ++ const gsl_matrix * A, ++ gsl_matrix * B); ++ ++int gsl_blas_cgemm (CBLAS_TRANSPOSE_t TransA, ++ CBLAS_TRANSPOSE_t TransB, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_matrix_complex_float * B, ++ const gsl_complex_float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_csymm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_matrix_complex_float * B, ++ const gsl_complex_float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_csyrk (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_complex_float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_csyr2k (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_matrix_complex_float * B, ++ const gsl_complex_float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_ctrmm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ gsl_matrix_complex_float * B); ++ ++int gsl_blas_ctrsm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ gsl_matrix_complex_float * B); ++ ++int gsl_blas_zgemm (CBLAS_TRANSPOSE_t TransA, ++ CBLAS_TRANSPOSE_t TransB, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_matrix_complex * B, ++ const gsl_complex beta, ++ gsl_matrix_complex * C); ++ ++int gsl_blas_zsymm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_matrix_complex * B, ++ const gsl_complex beta, ++ gsl_matrix_complex * C); ++ ++int gsl_blas_zsyrk (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_complex beta, ++ gsl_matrix_complex * C); ++ ++int gsl_blas_zsyr2k (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_matrix_complex * B, ++ const gsl_complex beta, ++ gsl_matrix_complex *C); ++ ++int gsl_blas_ztrmm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ gsl_matrix_complex * B); ++ ++int gsl_blas_ztrsm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, ++ CBLAS_DIAG_t Diag, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ gsl_matrix_complex * B); ++ ++/* ++ * Routines with prefixes C and Z only ++ */ ++int gsl_blas_chemm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_matrix_complex_float * B, ++ const gsl_complex_float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_cherk (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ float alpha, ++ const gsl_matrix_complex_float * A, ++ float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_cher2k (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex_float alpha, ++ const gsl_matrix_complex_float * A, ++ const gsl_matrix_complex_float * B, ++ float beta, ++ gsl_matrix_complex_float * C); ++ ++int gsl_blas_zhemm (CBLAS_SIDE_t Side, ++ CBLAS_UPLO_t Uplo, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_matrix_complex * B, ++ const gsl_complex beta, ++ gsl_matrix_complex * C); ++ ++int gsl_blas_zherk (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ double alpha, ++ const gsl_matrix_complex * A, ++ double beta, ++ gsl_matrix_complex * C); ++ ++int gsl_blas_zher2k (CBLAS_UPLO_t Uplo, ++ CBLAS_TRANSPOSE_t Trans, ++ const gsl_complex alpha, ++ const gsl_matrix_complex * A, ++ const gsl_matrix_complex * B, ++ double beta, ++ gsl_matrix_complex * C); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_BLAS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_SHORT_H__ ++#define __GSL_VECTOR_SHORT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ short *data; ++ gsl_block_short *block; ++ int owner; ++} ++gsl_vector_short; ++ ++typedef struct ++{ ++ gsl_vector_short vector; ++} _gsl_vector_short_view; ++ ++typedef _gsl_vector_short_view gsl_vector_short_view; ++ ++typedef struct ++{ ++ gsl_vector_short vector; ++} _gsl_vector_short_const_view; ++ ++typedef const _gsl_vector_short_const_view gsl_vector_short_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_short *gsl_vector_short_alloc (const size_t n); ++gsl_vector_short *gsl_vector_short_calloc (const size_t n); ++ ++gsl_vector_short *gsl_vector_short_alloc_from_block (gsl_block_short * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_short *gsl_vector_short_alloc_from_vector (gsl_vector_short * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_short_free (gsl_vector_short * v); ++ ++/* Views */ ++ ++_gsl_vector_short_view ++gsl_vector_short_view_array (short *v, size_t n); ++ ++_gsl_vector_short_view ++gsl_vector_short_view_array_with_stride (short *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_short_const_view ++gsl_vector_short_const_view_array (const short *v, size_t n); ++ ++_gsl_vector_short_const_view ++gsl_vector_short_const_view_array_with_stride (const short *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_short_view ++gsl_vector_short_subvector (gsl_vector_short *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_short_view ++gsl_vector_short_subvector_with_stride (gsl_vector_short *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_short_const_view ++gsl_vector_short_const_subvector (const gsl_vector_short *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_short_const_view ++gsl_vector_short_const_subvector_with_stride (const gsl_vector_short *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_short_set_zero (gsl_vector_short * v); ++void gsl_vector_short_set_all (gsl_vector_short * v, short x); ++int gsl_vector_short_set_basis (gsl_vector_short * v, size_t i); ++ ++int gsl_vector_short_fread (FILE * stream, gsl_vector_short * v); ++int gsl_vector_short_fwrite (FILE * stream, const gsl_vector_short * v); ++int gsl_vector_short_fscanf (FILE * stream, gsl_vector_short * v); ++int gsl_vector_short_fprintf (FILE * stream, const gsl_vector_short * v, ++ const char *format); ++ ++int gsl_vector_short_memcpy (gsl_vector_short * dest, const gsl_vector_short * src); ++ ++int gsl_vector_short_reverse (gsl_vector_short * v); ++ ++int gsl_vector_short_swap (gsl_vector_short * v, gsl_vector_short * w); ++int gsl_vector_short_swap_elements (gsl_vector_short * v, const size_t i, const size_t j); ++ ++short gsl_vector_short_max (const gsl_vector_short * v); ++short gsl_vector_short_min (const gsl_vector_short * v); ++void gsl_vector_short_minmax (const gsl_vector_short * v, short * min_out, short * max_out); ++ ++size_t gsl_vector_short_max_index (const gsl_vector_short * v); ++size_t gsl_vector_short_min_index (const gsl_vector_short * v); ++void gsl_vector_short_minmax_index (const gsl_vector_short * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_short_add (gsl_vector_short * a, const gsl_vector_short * b); ++int gsl_vector_short_sub (gsl_vector_short * a, const gsl_vector_short * b); ++int gsl_vector_short_mul (gsl_vector_short * a, const gsl_vector_short * b); ++int gsl_vector_short_div (gsl_vector_short * a, const gsl_vector_short * b); ++int gsl_vector_short_scale (gsl_vector_short * a, const double x); ++int gsl_vector_short_add_constant (gsl_vector_short * a, const double x); ++ ++int gsl_vector_short_equal (const gsl_vector_short * u, ++ const gsl_vector_short * v); ++ ++int gsl_vector_short_isnull (const gsl_vector_short * v); ++int gsl_vector_short_ispos (const gsl_vector_short * v); ++int gsl_vector_short_isneg (const gsl_vector_short * v); ++int gsl_vector_short_isnonneg (const gsl_vector_short * v); ++ ++INLINE_DECL short gsl_vector_short_get (const gsl_vector_short * v, const size_t i); ++INLINE_DECL void gsl_vector_short_set (gsl_vector_short * v, const size_t i, short x); ++INLINE_DECL short * gsl_vector_short_ptr (gsl_vector_short * v, const size_t i); ++INLINE_DECL const short * gsl_vector_short_const_ptr (const gsl_vector_short * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++short ++gsl_vector_short_get (const gsl_vector_short * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_short_set (gsl_vector_short * v, const size_t i, short x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++short * ++gsl_vector_short_ptr (gsl_vector_short * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (short *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const short * ++gsl_vector_short_const_ptr (const gsl_vector_short * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const short *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_SHORT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h (revision 14078) +@@ -0,0 +1,85 @@ ++/* fit/gsl_fit.h ++ * ++ * Copyright (C) 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FIT_H__ ++#define __GSL_FIT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_fit_linear (const double * x, const size_t xstride, ++ const double * y, const size_t ystride, ++ const size_t n, ++ double * c0, double * c1, ++ double * cov00, double * cov01, double * cov11, ++ double * sumsq); ++ ++ ++int gsl_fit_wlinear (const double * x, const size_t xstride, ++ const double * w, const size_t wstride, ++ const double * y, const size_t ystride, ++ const size_t n, ++ double * c0, double * c1, ++ double * cov00, double * cov01, double * cov11, ++ double * chisq); ++ ++int ++gsl_fit_linear_est (const double x, ++ const double c0, const double c1, ++ const double cov00, const double cov01, const double cov11, ++ double *y, double *y_err); ++ ++ ++int gsl_fit_mul (const double * x, const size_t xstride, ++ const double * y, const size_t ystride, ++ const size_t n, ++ double * c1, ++ double * cov11, ++ double * sumsq); ++ ++int gsl_fit_wmul (const double * x, const size_t xstride, ++ const double * w, const size_t wstride, ++ const double * y, const size_t ystride, ++ const size_t n, ++ double * c1, ++ double * cov11, ++ double * sumsq); ++ ++ ++int ++gsl_fit_mul_est (const double x, ++ const double c1, ++ const double cov11, ++ double *y, double *y_err); ++ ++__END_DECLS ++ ++#endif /* __GSL_FIT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h (revision 14078) +@@ -0,0 +1,179 @@ ++/* poly/gsl_poly.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_POLY_H__ ++#define __GSL_POLY_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Evaluate polynomial ++ * ++ * c[0] + c[1] x + c[2] x^2 + ... + c[len-1] x^(len-1) ++ * ++ * exceptions: none ++ */ ++ ++/* real polynomial, real x */ ++INLINE_DECL double gsl_poly_eval(const double c[], const int len, const double x); ++ ++/* real polynomial, complex x */ ++INLINE_DECL gsl_complex gsl_poly_complex_eval (const double c [], const int len, const gsl_complex z); ++ ++/* complex polynomial, complex x */ ++INLINE_DECL gsl_complex gsl_complex_poly_complex_eval (const gsl_complex c [], const int len, const gsl_complex z); ++ ++int gsl_poly_eval_derivs(const double c[], const size_t lenc, const double x, double res[], const size_t lenres); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++double ++gsl_poly_eval(const double c[], const int len, const double x) ++{ ++ int i; ++ double ans = c[len-1]; ++ for(i=len-1; i>0; i--) ans = c[i-1] + x * ans; ++ return ans; ++} ++ ++INLINE_FUN ++gsl_complex ++gsl_poly_complex_eval(const double c[], const int len, const gsl_complex z) ++{ ++ int i; ++ gsl_complex ans; ++ GSL_SET_COMPLEX (&ans, c[len-1], 0.0); ++ for(i=len-1; i>0; i--) { ++ /* The following three lines are equivalent to ++ ans = gsl_complex_add_real (gsl_complex_mul (z, ans), c[i-1]); ++ but faster */ ++ double tmp = c[i-1] + GSL_REAL (z) * GSL_REAL (ans) - GSL_IMAG (z) * GSL_IMAG (ans); ++ GSL_SET_IMAG (&ans, GSL_IMAG (z) * GSL_REAL (ans) + GSL_REAL (z) * GSL_IMAG (ans)); ++ GSL_SET_REAL (&ans, tmp); ++ } ++ return ans; ++} ++ ++INLINE_FUN ++gsl_complex ++gsl_complex_poly_complex_eval(const gsl_complex c[], const int len, const gsl_complex z) ++{ ++ int i; ++ gsl_complex ans = c[len-1]; ++ for(i=len-1; i>0; i--) { ++ /* The following three lines are equivalent to ++ ans = gsl_complex_add (c[i-1], gsl_complex_mul (x, ans)); ++ but faster */ ++ double tmp = GSL_REAL (c[i-1]) + GSL_REAL (z) * GSL_REAL (ans) - GSL_IMAG (z) * GSL_IMAG (ans); ++ GSL_SET_IMAG (&ans, GSL_IMAG (c[i-1]) + GSL_IMAG (z) * GSL_REAL (ans) + GSL_REAL (z) * GSL_IMAG (ans)); ++ GSL_SET_REAL (&ans, tmp); ++ } ++ return ans; ++} ++#endif /* HAVE_INLINE */ ++ ++/* Work with divided-difference polynomials, Abramowitz & Stegun 25.2.26 */ ++ ++int ++gsl_poly_dd_init (double dd[], const double x[], const double y[], ++ size_t size); ++ ++INLINE_DECL double ++gsl_poly_dd_eval (const double dd[], const double xa[], const size_t size, const double x); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++double ++gsl_poly_dd_eval(const double dd[], const double xa[], const size_t size, const double x) ++{ ++ size_t i; ++ double y = dd[size - 1]; ++ for (i = size - 1; i--;) y = dd[i] + (x - xa[i]) * y; ++ return y; ++} ++#endif /* HAVE_INLINE */ ++ ++ ++int ++gsl_poly_dd_taylor (double c[], double xp, ++ const double dd[], const double x[], size_t size, ++ double w[]); ++ ++/* Solve for real or complex roots of the standard quadratic equation, ++ * returning the number of real roots. ++ * ++ * Roots are returned ordered. ++ */ ++int gsl_poly_solve_quadratic (double a, double b, double c, ++ double * x0, double * x1); ++ ++int ++gsl_poly_complex_solve_quadratic (double a, double b, double c, ++ gsl_complex * z0, gsl_complex * z1); ++ ++ ++/* Solve for real roots of the cubic equation ++ * x^3 + a x^2 + b x + c = 0, returning the ++ * number of real roots. ++ * ++ * Roots are returned ordered. ++ */ ++int gsl_poly_solve_cubic (double a, double b, double c, ++ double * x0, double * x1, double * x2); ++ ++int ++gsl_poly_complex_solve_cubic (double a, double b, double c, ++ gsl_complex * z0, gsl_complex * z1, ++ gsl_complex * z2); ++ ++ ++/* Solve for the complex roots of a general real polynomial */ ++ ++typedef struct ++{ ++ size_t nc ; ++ double * matrix ; ++} ++gsl_poly_complex_workspace ; ++ ++gsl_poly_complex_workspace * gsl_poly_complex_workspace_alloc (size_t n); ++void gsl_poly_complex_workspace_free (gsl_poly_complex_workspace * w); ++ ++int ++gsl_poly_complex_solve (const double * a, size_t n, ++ gsl_poly_complex_workspace * w, ++ gsl_complex_packed_ptr z); ++ ++__END_DECLS ++ ++#endif /* __GSL_POLY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h (revision 14078) +@@ -0,0 +1,111 @@ ++/* min/gsl_min.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MIN_H__ ++#define __GSL_MIN_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*set) (void *state, gsl_function * f, double x_minimum, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper); ++ int (*iterate) (void *state, gsl_function * f, double * x_minimum, double * f_minimum, double * x_lower, double * f_lower, double * x_upper, double * f_upper); ++ } ++gsl_min_fminimizer_type; ++ ++typedef struct ++ { ++ const gsl_min_fminimizer_type * type; ++ gsl_function * function ; ++ double x_minimum ; ++ double x_lower ; ++ double x_upper ; ++ double f_minimum, f_lower, f_upper; ++ void *state; ++ } ++gsl_min_fminimizer; ++ ++gsl_min_fminimizer * ++gsl_min_fminimizer_alloc (const gsl_min_fminimizer_type * T) ; ++ ++void gsl_min_fminimizer_free (gsl_min_fminimizer * s); ++ ++int gsl_min_fminimizer_set (gsl_min_fminimizer * s, ++ gsl_function * f, double x_minimum, ++ double x_lower, double x_upper); ++ ++int gsl_min_fminimizer_set_with_values (gsl_min_fminimizer * s, ++ gsl_function * f, ++ double x_minimum, double f_minimum, ++ double x_lower, double f_lower, ++ double x_upper, double f_upper); ++ ++int gsl_min_fminimizer_iterate (gsl_min_fminimizer * s); ++ ++const char * gsl_min_fminimizer_name (const gsl_min_fminimizer * s); ++ ++double gsl_min_fminimizer_x_minimum (const gsl_min_fminimizer * s); ++double gsl_min_fminimizer_x_lower (const gsl_min_fminimizer * s); ++double gsl_min_fminimizer_x_upper (const gsl_min_fminimizer * s); ++double gsl_min_fminimizer_f_minimum (const gsl_min_fminimizer * s); ++double gsl_min_fminimizer_f_lower (const gsl_min_fminimizer * s); ++double gsl_min_fminimizer_f_upper (const gsl_min_fminimizer * s); ++ ++/* Deprecated, use x_minimum instead */ ++double gsl_min_fminimizer_minimum (const gsl_min_fminimizer * s); ++ ++int ++gsl_min_test_interval (double x_lower, double x_upper, double epsabs, double epsrel); ++ ++GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_goldensection; ++GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_brent; ++GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_quad_golden; ++ ++typedef ++int (*gsl_min_bracketing_function)(gsl_function *f, ++ double *x_minimum,double * f_minimum, ++ double *x_lower, double * f_lower, ++ double *x_upper, double * f_upper, ++ size_t eval_max); ++ ++int ++gsl_min_find_bracket(gsl_function *f,double *x_minimum,double * f_minimum, ++ double *x_lower, double * f_lower, ++ double *x_upper, double * f_upper, ++ size_t eval_max); ++ ++__END_DECLS ++ ++#endif /* __GSL_MIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h (revision 14078) +@@ -0,0 +1,323 @@ ++/* integration/gsl_integration.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_INTEGRATION_H__ ++#define __GSL_INTEGRATION_H__ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Workspace for adaptive integrators */ ++ ++typedef struct ++ { ++ size_t limit; ++ size_t size; ++ size_t nrmax; ++ size_t i; ++ size_t maximum_level; ++ double *alist; ++ double *blist; ++ double *rlist; ++ double *elist; ++ size_t *order; ++ size_t *level; ++ } ++gsl_integration_workspace; ++ ++gsl_integration_workspace * ++ gsl_integration_workspace_alloc (const size_t n); ++ ++void ++ gsl_integration_workspace_free (gsl_integration_workspace * w); ++ ++ ++/* Workspace for QAWS integrator */ ++ ++typedef struct ++{ ++ double alpha; ++ double beta; ++ int mu; ++ int nu; ++ double ri[25]; ++ double rj[25]; ++ double rg[25]; ++ double rh[25]; ++} ++gsl_integration_qaws_table; ++ ++gsl_integration_qaws_table * ++gsl_integration_qaws_table_alloc (double alpha, double beta, int mu, int nu); ++ ++int ++gsl_integration_qaws_table_set (gsl_integration_qaws_table * t, ++ double alpha, double beta, int mu, int nu); ++ ++void ++gsl_integration_qaws_table_free (gsl_integration_qaws_table * t); ++ ++/* Workspace for QAWO integrator */ ++ ++enum gsl_integration_qawo_enum { GSL_INTEG_COSINE, GSL_INTEG_SINE }; ++ ++typedef struct ++{ ++ size_t n; ++ double omega; ++ double L; ++ double par; ++ enum gsl_integration_qawo_enum sine; ++ double *chebmo; ++} ++gsl_integration_qawo_table; ++ ++gsl_integration_qawo_table * ++gsl_integration_qawo_table_alloc (double omega, double L, ++ enum gsl_integration_qawo_enum sine, ++ size_t n); ++ ++int ++gsl_integration_qawo_table_set (gsl_integration_qawo_table * t, ++ double omega, double L, ++ enum gsl_integration_qawo_enum sine); ++ ++int ++gsl_integration_qawo_table_set_length (gsl_integration_qawo_table * t, ++ double L); ++ ++void ++gsl_integration_qawo_table_free (gsl_integration_qawo_table * t); ++ ++ ++/* Definition of an integration rule */ ++ ++typedef void gsl_integration_rule (const gsl_function * f, ++ double a, double b, ++ double *result, double *abserr, ++ double *defabs, double *resabs); ++ ++void gsl_integration_qk15 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qk21 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qk31 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qk41 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qk51 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qk61 (const gsl_function * f, double a, double b, ++ double *result, double *abserr, ++ double *resabs, double *resasc); ++ ++void gsl_integration_qcheb (gsl_function * f, double a, double b, ++ double *cheb12, double *cheb24); ++ ++/* The low-level integration rules in QUADPACK are identified by small ++ integers (1-6). We'll use symbolic constants to refer to them. */ ++ ++enum ++ { ++ GSL_INTEG_GAUSS15 = 1, /* 15 point Gauss-Kronrod rule */ ++ GSL_INTEG_GAUSS21 = 2, /* 21 point Gauss-Kronrod rule */ ++ GSL_INTEG_GAUSS31 = 3, /* 31 point Gauss-Kronrod rule */ ++ GSL_INTEG_GAUSS41 = 4, /* 41 point Gauss-Kronrod rule */ ++ GSL_INTEG_GAUSS51 = 5, /* 51 point Gauss-Kronrod rule */ ++ GSL_INTEG_GAUSS61 = 6 /* 61 point Gauss-Kronrod rule */ ++ }; ++ ++void ++gsl_integration_qk (const int n, const double xgk[], ++ const double wg[], const double wgk[], ++ double fv1[], double fv2[], ++ const gsl_function *f, double a, double b, ++ double * result, double * abserr, ++ double * resabs, double * resasc); ++ ++ ++int gsl_integration_qng (const gsl_function * f, ++ double a, double b, ++ double epsabs, double epsrel, ++ double *result, double *abserr, ++ size_t * neval); ++ ++int gsl_integration_qag (const gsl_function * f, ++ double a, double b, ++ double epsabs, double epsrel, size_t limit, ++ int key, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qagi (gsl_function * f, ++ double epsabs, double epsrel, size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qagiu (gsl_function * f, ++ double a, ++ double epsabs, double epsrel, size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qagil (gsl_function * f, ++ double b, ++ double epsabs, double epsrel, size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++ ++int gsl_integration_qags (const gsl_function * f, ++ double a, double b, ++ double epsabs, double epsrel, size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qagp (const gsl_function * f, ++ double *pts, size_t npts, ++ double epsabs, double epsrel, size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qawc (gsl_function *f, ++ const double a, const double b, const double c, ++ const double epsabs, const double epsrel, const size_t limit, ++ gsl_integration_workspace * workspace, ++ double * result, double * abserr); ++ ++int gsl_integration_qaws (gsl_function * f, ++ const double a, const double b, ++ gsl_integration_qaws_table * t, ++ const double epsabs, const double epsrel, ++ const size_t limit, ++ gsl_integration_workspace * workspace, ++ double *result, double *abserr); ++ ++int gsl_integration_qawo (gsl_function * f, ++ const double a, ++ const double epsabs, const double epsrel, ++ const size_t limit, ++ gsl_integration_workspace * workspace, ++ gsl_integration_qawo_table * wf, ++ double *result, double *abserr); ++ ++int gsl_integration_qawf (gsl_function * f, ++ const double a, ++ const double epsabs, ++ const size_t limit, ++ gsl_integration_workspace * workspace, ++ gsl_integration_workspace * cycle_workspace, ++ gsl_integration_qawo_table * wf, ++ double *result, double *abserr); ++ ++/* Workspace for fixed-order Gauss-Legendre integration */ ++ ++typedef struct ++ { ++ size_t n; /* number of points */ ++ double *x; /* Gauss abscissae/points */ ++ double *w; /* Gauss weights for each abscissae */ ++ int precomputed; /* high precision abscissae/weights precomputed? */ ++ } ++gsl_integration_glfixed_table; ++ ++ ++gsl_integration_glfixed_table * ++ gsl_integration_glfixed_table_alloc (size_t n); ++ ++void ++ gsl_integration_glfixed_table_free (gsl_integration_glfixed_table * t); ++ ++/* Routine for fixed-order Gauss-Legendre integration */ ++ ++double ++ gsl_integration_glfixed (const gsl_function *f, ++ double a, ++ double b, ++ const gsl_integration_glfixed_table * t); ++ ++/* Routine to retrieve the i-th Gauss-Legendre point and weight from t */ ++ ++int ++ gsl_integration_glfixed_point (double a, ++ double b, ++ size_t i, ++ double *xi, ++ double *wi, ++ const gsl_integration_glfixed_table * t); ++ ++ ++/* Cquad integration - Pedro Gonnet */ ++ ++/* Data of a single interval */ ++typedef struct ++{ ++ double a, b; ++ double c[64]; ++ double fx[33]; ++ double igral, err; ++ int depth, rdepth, ndiv; ++} gsl_integration_cquad_ival; ++ ++ ++/* The workspace is just a collection of intervals */ ++typedef struct ++{ ++ size_t size; ++ gsl_integration_cquad_ival *ivals; ++ size_t *heap; ++} gsl_integration_cquad_workspace; ++ ++gsl_integration_cquad_workspace * ++gsl_integration_cquad_workspace_alloc (const size_t n); ++ ++void ++gsl_integration_cquad_workspace_free (gsl_integration_cquad_workspace * w); ++ ++int ++gsl_integration_cquad (const gsl_function * f, double a, double b, ++ double epsabs, double epsrel, ++ gsl_integration_cquad_workspace * ws, ++ double *result, double *abserr, size_t * nevals); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_INTEGRATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h (revision 14078) +@@ -0,0 +1,88 @@ ++/* gsl_mode.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: B. Gough and G. Jungman */ ++ ++#ifndef __GSL_MODE_H__ ++#define __GSL_MODE_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Some functions can take a mode argument. This ++ * is a rough method to do things like control ++ * the precision of the algorithm. This mainly ++ * occurs in special functions, but we figured ++ * it was ok to have a general facility. ++ * ++ * The mode type is 32-bit field. Most of ++ * the fields are currently unused. Users ++ * '|' various predefined constants to get ++ * a desired mode. ++ */ ++typedef unsigned int gsl_mode_t; ++ ++ ++/* Here are the predefined constants. ++ * Note that the precision constants ++ * are special because they are used ++ * to index arrays, so do not change ++ * them. The precision information is ++ * in the low order 3 bits of gsl_mode_t ++ * (the third bit is currently unused). ++ */ ++ ++/* Note that "0" is double precision, ++ * so that you get that by default if ++ * you forget a flag. ++ */ ++#define GSL_PREC_DOUBLE 0 ++#define GSL_PREC_SINGLE 1 ++#define GSL_PREC_APPROX 2 ++ ++#ifdef HAVE_INLINE ++INLINE_FUN unsigned int GSL_MODE_PREC(gsl_mode_t mt); ++ ++INLINE_FUN unsigned int ++GSL_MODE_PREC(gsl_mode_t mt) ++{ return (mt & (unsigned int)7); } ++#else /* HAVE_INLINE */ ++#define GSL_MODE_PREC(mt) ((mt) & (unsigned int)7) ++#endif /* HAVE_INLINE */ ++ ++ ++/* Here are some predefined generic modes. ++ */ ++#define GSL_MODE_DEFAULT 0 ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_MODE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_CHAR_H__ ++#define __GSL_SORT_CHAR_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_char (char * data, const size_t stride, const size_t n); ++void gsl_sort_char_index (size_t * p, const char * data, const size_t stride, const size_t n); ++ ++int gsl_sort_char_smallest (char * dest, const size_t k, const char * src, const size_t stride, const size_t n); ++int gsl_sort_char_smallest_index (size_t * p, const size_t k, const char * src, const size_t stride, const size_t n); ++ ++int gsl_sort_char_largest (char * dest, const size_t k, const char * src, const size_t stride, const size_t n); ++int gsl_sort_char_largest_index (size_t * p, const size_t k, const char * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_UCHAR_H__ ++#define __GSL_PERMUTE_VECTOR_UCHAR_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_uchar (const gsl_permutation * p, gsl_vector_uchar * v); ++int gsl_permute_vector_uchar_inverse (const gsl_permutation * p, gsl_vector_uchar * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_CHAR_H__ ++#define __GSL_BLOCK_CHAR_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_char_struct ++{ ++ size_t size; ++ char *data; ++}; ++ ++typedef struct gsl_block_char_struct gsl_block_char; ++ ++gsl_block_char *gsl_block_char_alloc (const size_t n); ++gsl_block_char *gsl_block_char_calloc (const size_t n); ++void gsl_block_char_free (gsl_block_char * b); ++ ++int gsl_block_char_fread (FILE * stream, gsl_block_char * b); ++int gsl_block_char_fwrite (FILE * stream, const gsl_block_char * b); ++int gsl_block_char_fscanf (FILE * stream, gsl_block_char * b); ++int gsl_block_char_fprintf (FILE * stream, const gsl_block_char * b, const char *format); ++ ++int gsl_block_char_raw_fread (FILE * stream, char * b, const size_t n, const size_t stride); ++int gsl_block_char_raw_fwrite (FILE * stream, const char * b, const size_t n, const size_t stride); ++int gsl_block_char_raw_fscanf (FILE * stream, char * b, const size_t n, const size_t stride); ++int gsl_block_char_raw_fprintf (FILE * stream, const char * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_char_size (const gsl_block_char * b); ++char * gsl_block_char_data (const gsl_block_char * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h (revision 14078) +@@ -0,0 +1,332 @@ ++/* ode-initval/odeiv2.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++/* Modified by Tuomo Keskitalo */ ++ ++#ifndef __GSL_ODEIV2_H__ ++#define __GSL_ODEIV2_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++/* Description of a system of ODEs. ++ * ++ * y' = f(t,y) = dydt(t, y) ++ * ++ * The system is specified by giving the right-hand-side ++ * of the equation and possibly a jacobian function. ++ * ++ * Some methods require the jacobian function, which calculates ++ * the matrix dfdy and the vector dfdt. The matrix dfdy conforms ++ * to the GSL standard, being a continuous range of floating point ++ * values, in row-order. ++ * ++ * As with GSL function objects, user-supplied parameter ++ * data is also present. ++ */ ++ typedef struct ++{ ++ int (*function) (double t, const double y[], double dydt[], void *params); ++ int (*jacobian) (double t, const double y[], double *dfdy, double dfdt[], ++ void *params); ++ size_t dimension; ++ void *params; ++} ++gsl_odeiv2_system; ++ ++/* Function evaluation macros */ ++ ++#define GSL_ODEIV_FN_EVAL(S,t,y,f) (*((S)->function))(t,y,f,(S)->params) ++#define GSL_ODEIV_JA_EVAL(S,t,y,dfdy,dfdt) (*((S)->jacobian))(t,y,dfdy,dfdt,(S)->params) ++ ++/* Type definitions */ ++ ++typedef struct gsl_odeiv2_step_struct gsl_odeiv2_step; ++typedef struct gsl_odeiv2_control_struct gsl_odeiv2_control; ++typedef struct gsl_odeiv2_evolve_struct gsl_odeiv2_evolve; ++typedef struct gsl_odeiv2_driver_struct gsl_odeiv2_driver; ++ ++/* Stepper object ++ * ++ * Opaque object for stepping an ODE system from t to t+h. ++ * In general the object has some state which facilitates ++ * iterating the stepping operation. ++ */ ++ ++typedef struct ++{ ++ const char *name; ++ int can_use_dydt_in; ++ int gives_exact_dydt_out; ++ void *(*alloc) (size_t dim); ++ int (*apply) (void *state, size_t dim, double t, double h, double y[], ++ double yerr[], const double dydt_in[], double dydt_out[], ++ const gsl_odeiv2_system * dydt); ++ int (*set_driver) (void *state, const gsl_odeiv2_driver * d); ++ int (*reset) (void *state, size_t dim); ++ unsigned int (*order) (void *state); ++ void (*free) (void *state); ++} ++gsl_odeiv2_step_type; ++ ++struct gsl_odeiv2_step_struct ++{ ++ const gsl_odeiv2_step_type *type; ++ size_t dimension; ++ void *state; ++}; ++ ++/* Available stepper types */ ++ ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk2; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk4; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rkf45; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rkck; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk8pd; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk2imp; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk4imp; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_bsimp; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk1imp; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_msadams; ++GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_msbdf; ++ ++/* Stepper object methods */ ++ ++gsl_odeiv2_step *gsl_odeiv2_step_alloc (const gsl_odeiv2_step_type * T, ++ size_t dim); ++int gsl_odeiv2_step_reset (gsl_odeiv2_step * s); ++void gsl_odeiv2_step_free (gsl_odeiv2_step * s); ++const char *gsl_odeiv2_step_name (const gsl_odeiv2_step * s); ++unsigned int gsl_odeiv2_step_order (const gsl_odeiv2_step * s); ++int gsl_odeiv2_step_apply (gsl_odeiv2_step * s, double t, double h, ++ double y[], double yerr[], const double dydt_in[], ++ double dydt_out[], const gsl_odeiv2_system * dydt); ++int gsl_odeiv2_step_set_driver (gsl_odeiv2_step * s, ++ const gsl_odeiv2_driver * d); ++ ++/* Step size control object. */ ++ ++typedef struct ++{ ++ const char *name; ++ void *(*alloc) (void); ++ int (*init) (void *state, double eps_abs, double eps_rel, double a_y, ++ double a_dydt); ++ int (*hadjust) (void *state, size_t dim, unsigned int ord, const double y[], ++ const double yerr[], const double yp[], double *h); ++ int (*errlevel) (void *state, const double y, const double dydt, ++ const double h, const size_t ind, double *errlev); ++ int (*set_driver) (void *state, const gsl_odeiv2_driver * d); ++ void (*free) (void *state); ++} ++gsl_odeiv2_control_type; ++ ++struct gsl_odeiv2_control_struct ++{ ++ const gsl_odeiv2_control_type *type; ++ void *state; ++}; ++ ++/* Possible return values for an hadjust() evolution method */ ++ ++#define GSL_ODEIV_HADJ_INC 1 /* step was increased */ ++#define GSL_ODEIV_HADJ_NIL 0 /* step unchanged */ ++#define GSL_ODEIV_HADJ_DEC (-1) /* step decreased */ ++ ++/* General step size control methods. ++ * ++ * The hadjust() method controls the adjustment of ++ * step size given the result of a step and the error. ++ * Valid hadjust() methods must return one of the codes below. ++ * errlevel function calculates the desired error level D0. ++ * ++ * The general data can be used by specializations ++ * to store state and control their heuristics. ++ */ ++ ++gsl_odeiv2_control *gsl_odeiv2_control_alloc (const gsl_odeiv2_control_type * ++ T); ++int gsl_odeiv2_control_init (gsl_odeiv2_control * c, double eps_abs, ++ double eps_rel, double a_y, double a_dydt); ++void gsl_odeiv2_control_free (gsl_odeiv2_control * c); ++int gsl_odeiv2_control_hadjust (gsl_odeiv2_control * c, gsl_odeiv2_step * s, ++ const double y[], const double yerr[], ++ const double dydt[], double *h); ++const char *gsl_odeiv2_control_name (const gsl_odeiv2_control * c); ++int gsl_odeiv2_control_errlevel (gsl_odeiv2_control * c, const double y, ++ const double dydt, const double h, ++ const size_t ind, double *errlev); ++int gsl_odeiv2_control_set_driver (gsl_odeiv2_control * c, ++ const gsl_odeiv2_driver * d); ++ ++/* Available control object constructors. ++ * ++ * The standard control object is a four parameter heuristic ++ * defined as follows: ++ * D0 = eps_abs + eps_rel * (a_y |y| + a_dydt h |y'|) ++ * D1 = |yerr| ++ * q = consistency order of method (q=4 for 4(5) embedded RK) ++ * S = safety factor (0.9 say) ++ * ++ * / (D0/D1)^(1/(q+1)) D0 >= D1 ++ * h_NEW = S h_OLD * | ++ * \ (D0/D1)^(1/q) D0 < D1 ++ * ++ * This encompasses all the standard error scaling methods. ++ * ++ * The y method is the standard method with a_y=1, a_dydt=0. ++ * The yp method is the standard method with a_y=0, a_dydt=1. ++ */ ++ ++gsl_odeiv2_control *gsl_odeiv2_control_standard_new (double eps_abs, ++ double eps_rel, ++ double a_y, ++ double a_dydt); ++gsl_odeiv2_control *gsl_odeiv2_control_y_new (double eps_abs, double eps_rel); ++gsl_odeiv2_control *gsl_odeiv2_control_yp_new (double eps_abs, ++ double eps_rel); ++ ++/* This controller computes errors using different absolute errors for ++ * each component ++ * ++ * D0 = eps_abs * scale_abs[i] + eps_rel * (a_y |y| + a_dydt h |y'|) ++ */ ++ ++gsl_odeiv2_control *gsl_odeiv2_control_scaled_new (double eps_abs, ++ double eps_rel, double a_y, ++ double a_dydt, ++ const double scale_abs[], ++ size_t dim); ++ ++/* Evolution object */ ++ ++struct gsl_odeiv2_evolve_struct ++{ ++ size_t dimension; ++ double *y0; ++ double *yerr; ++ double *dydt_in; ++ double *dydt_out; ++ double last_step; ++ unsigned long int count; ++ unsigned long int failed_steps; ++ const gsl_odeiv2_driver *driver; ++}; ++ ++/* Evolution object methods */ ++ ++gsl_odeiv2_evolve *gsl_odeiv2_evolve_alloc (size_t dim); ++int gsl_odeiv2_evolve_apply (gsl_odeiv2_evolve * e, gsl_odeiv2_control * con, ++ gsl_odeiv2_step * step, ++ const gsl_odeiv2_system * dydt, double *t, ++ double t1, double *h, double y[]); ++int gsl_odeiv2_evolve_apply_fixed_step (gsl_odeiv2_evolve * e, ++ gsl_odeiv2_control * con, ++ gsl_odeiv2_step * step, ++ const gsl_odeiv2_system * dydt, ++ double *t, const double h0, ++ double y[]); ++int gsl_odeiv2_evolve_reset (gsl_odeiv2_evolve * e); ++void gsl_odeiv2_evolve_free (gsl_odeiv2_evolve * e); ++int gsl_odeiv2_evolve_set_driver (gsl_odeiv2_evolve * e, ++ const gsl_odeiv2_driver * d); ++ ++/* Driver object ++ * ++ * This is a high level wrapper for step, control and ++ * evolve objects. ++ */ ++ ++struct gsl_odeiv2_driver_struct ++{ ++ const gsl_odeiv2_system *sys; /* ODE system */ ++ gsl_odeiv2_step *s; /* stepper object */ ++ gsl_odeiv2_control *c; /* control object */ ++ gsl_odeiv2_evolve *e; /* evolve object */ ++ double h; /* step size */ ++ double hmin; /* minimum step size allowed */ ++ double hmax; /* maximum step size allowed */ ++ unsigned long int n; /* number of steps taken */ ++ unsigned long int nmax; /* Maximum number of steps allowed */ ++}; ++ ++/* Driver object methods */ ++ ++gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_y_new (const gsl_odeiv2_system * ++ sys, ++ const gsl_odeiv2_step_type * ++ T, const double hstart, ++ const double epsabs, ++ const double epsrel); ++gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_yp_new (const gsl_odeiv2_system * ++ sys, ++ const gsl_odeiv2_step_type ++ * T, const double hstart, ++ const double epsabs, ++ const double epsrel); ++gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_scaled_new (const gsl_odeiv2_system ++ * sys, ++ const ++ gsl_odeiv2_step_type * ++ T, const double hstart, ++ const double epsabs, ++ const double epsrel, ++ const double a_y, ++ const double a_dydt, ++ const double ++ scale_abs[]); ++gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_standard_new (const ++ gsl_odeiv2_system * ++ sys, ++ const ++ gsl_odeiv2_step_type ++ * T, ++ const double hstart, ++ const double epsabs, ++ const double epsrel, ++ const double a_y, ++ const double a_dydt); ++int gsl_odeiv2_driver_set_hmin (gsl_odeiv2_driver * d, const double hmin); ++int gsl_odeiv2_driver_set_hmax (gsl_odeiv2_driver * d, const double hmax); ++int gsl_odeiv2_driver_set_nmax (gsl_odeiv2_driver * d, ++ const unsigned long int nmax); ++int gsl_odeiv2_driver_apply (gsl_odeiv2_driver * d, double *t, ++ const double t1, double y[]); ++int gsl_odeiv2_driver_apply_fixed_step (gsl_odeiv2_driver * d, double *t, ++ const double h, ++ const unsigned long int n, ++ double y[]); ++int gsl_odeiv2_driver_reset (gsl_odeiv2_driver * d); ++void gsl_odeiv2_driver_free (gsl_odeiv2_driver * state); ++ ++__END_DECLS ++#endif /* __GSL_ODEIV2_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h (revision 14078) +@@ -0,0 +1,57 @@ ++/* vector/gsl_check_range.h ++ * ++ * Copyright (C) 2003, 2004, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CHECK_RANGE_H__ ++#define __GSL_CHECK_RANGE_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++GSL_VAR int gsl_check_range; ++ ++/* Turn range checking on by default, unless the user defines ++ GSL_RANGE_CHECK_OFF, or defines GSL_RANGE_CHECK to 0 explicitly */ ++ ++#ifdef GSL_RANGE_CHECK_OFF ++# ifndef GSL_RANGE_CHECK ++# define GSL_RANGE_CHECK 0 ++# else ++# error "cannot set both GSL_RANGE_CHECK and GSL_RANGE_CHECK_OFF" ++# endif ++#else ++# ifndef GSL_RANGE_CHECK ++# define GSL_RANGE_CHECK 1 ++# endif ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_CHECK_RANGE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h (revision 14078) +@@ -0,0 +1,24 @@ ++#ifndef __GSL_BLOCK_H__ ++#define __GSL_BLOCK_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_BLOCK_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h (revision 14078) +@@ -0,0 +1,66 @@ ++/* gsl_precision.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: B. Gough and G. Jungman */ ++ ++#ifndef __GSL_PRECISION_H__ ++#define __GSL_PRECISION_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* A type for the precision indicator. ++ * This is mainly for pedagogy. ++ */ ++typedef unsigned int gsl_prec_t; ++ ++ ++/* The number of precision types. ++ * Remember that precision-mode ++ * can index an array. ++ */ ++#define _GSL_PREC_T_NUM 3 ++ ++ ++/* Arrays containing derived ++ * precision constants for the ++ * different precision levels. ++ */ ++GSL_VAR const double gsl_prec_eps[]; ++GSL_VAR const double gsl_prec_sqrt_eps[]; ++GSL_VAR const double gsl_prec_root3_eps[]; ++GSL_VAR const double gsl_prec_root4_eps[]; ++GSL_VAR const double gsl_prec_root5_eps[]; ++GSL_VAR const double gsl_prec_root6_eps[]; ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_PRECISION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_ULONG_H__ ++#define __GSL_SORT_ULONG_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_ulong (unsigned long * data, const size_t stride, const size_t n); ++void gsl_sort_ulong_index (size_t * p, const unsigned long * data, const size_t stride, const size_t n); ++ ++int gsl_sort_ulong_smallest (unsigned long * dest, const size_t k, const unsigned long * src, const size_t stride, const size_t n); ++int gsl_sort_ulong_smallest_index (size_t * p, const size_t k, const unsigned long * src, const size_t stride, const size_t n); ++ ++int gsl_sort_ulong_largest (unsigned long * dest, const size_t k, const unsigned long * src, const size_t stride, const size_t n); ++int gsl_sort_ulong_largest_index (size_t * p, const size_t k, const unsigned long * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h (revision 14078) +@@ -0,0 +1,170 @@ ++/* cdf/gsl_cdf.h ++ * ++ * Copyright (C) 2002 Jason H. Stover. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++/* Author: J. Stover */ ++ ++#ifndef __GSL_CDF_H__ ++#define __GSL_CDF_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_cdf_ugaussian_P (const double x); ++double gsl_cdf_ugaussian_Q (const double x); ++ ++double gsl_cdf_ugaussian_Pinv (const double P); ++double gsl_cdf_ugaussian_Qinv (const double Q); ++ ++double gsl_cdf_gaussian_P (const double x, const double sigma); ++double gsl_cdf_gaussian_Q (const double x, const double sigma); ++ ++double gsl_cdf_gaussian_Pinv (const double P, const double sigma); ++double gsl_cdf_gaussian_Qinv (const double Q, const double sigma); ++ ++double gsl_cdf_gamma_P (const double x, const double a, const double b); ++double gsl_cdf_gamma_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_gamma_Pinv (const double P, const double a, const double b); ++double gsl_cdf_gamma_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_cauchy_P (const double x, const double a); ++double gsl_cdf_cauchy_Q (const double x, const double a); ++ ++double gsl_cdf_cauchy_Pinv (const double P, const double a); ++double gsl_cdf_cauchy_Qinv (const double Q, const double a); ++ ++double gsl_cdf_laplace_P (const double x, const double a); ++double gsl_cdf_laplace_Q (const double x, const double a); ++ ++double gsl_cdf_laplace_Pinv (const double P, const double a); ++double gsl_cdf_laplace_Qinv (const double Q, const double a); ++ ++double gsl_cdf_rayleigh_P (const double x, const double sigma); ++double gsl_cdf_rayleigh_Q (const double x, const double sigma); ++ ++double gsl_cdf_rayleigh_Pinv (const double P, const double sigma); ++double gsl_cdf_rayleigh_Qinv (const double Q, const double sigma); ++ ++double gsl_cdf_chisq_P (const double x, const double nu); ++double gsl_cdf_chisq_Q (const double x, const double nu); ++ ++double gsl_cdf_chisq_Pinv (const double P, const double nu); ++double gsl_cdf_chisq_Qinv (const double Q, const double nu); ++ ++double gsl_cdf_exponential_P (const double x, const double mu); ++double gsl_cdf_exponential_Q (const double x, const double mu); ++ ++double gsl_cdf_exponential_Pinv (const double P, const double mu); ++double gsl_cdf_exponential_Qinv (const double Q, const double mu); ++ ++double gsl_cdf_exppow_P (const double x, const double a, const double b); ++double gsl_cdf_exppow_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_tdist_P (const double x, const double nu); ++double gsl_cdf_tdist_Q (const double x, const double nu); ++ ++double gsl_cdf_tdist_Pinv (const double P, const double nu); ++double gsl_cdf_tdist_Qinv (const double Q, const double nu); ++ ++double gsl_cdf_fdist_P (const double x, const double nu1, const double nu2); ++double gsl_cdf_fdist_Q (const double x, const double nu1, const double nu2); ++ ++double gsl_cdf_fdist_Pinv (const double P, const double nu1, const double nu2); ++double gsl_cdf_fdist_Qinv (const double Q, const double nu1, const double nu2); ++ ++double gsl_cdf_beta_P (const double x, const double a, const double b); ++double gsl_cdf_beta_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_beta_Pinv (const double P, const double a, const double b); ++double gsl_cdf_beta_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_flat_P (const double x, const double a, const double b); ++double gsl_cdf_flat_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_flat_Pinv (const double P, const double a, const double b); ++double gsl_cdf_flat_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_lognormal_P (const double x, const double zeta, const double sigma); ++double gsl_cdf_lognormal_Q (const double x, const double zeta, const double sigma); ++ ++double gsl_cdf_lognormal_Pinv (const double P, const double zeta, const double sigma); ++double gsl_cdf_lognormal_Qinv (const double Q, const double zeta, const double sigma); ++ ++double gsl_cdf_gumbel1_P (const double x, const double a, const double b); ++double gsl_cdf_gumbel1_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_gumbel1_Pinv (const double P, const double a, const double b); ++double gsl_cdf_gumbel1_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_gumbel2_P (const double x, const double a, const double b); ++double gsl_cdf_gumbel2_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_gumbel2_Pinv (const double P, const double a, const double b); ++double gsl_cdf_gumbel2_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_weibull_P (const double x, const double a, const double b); ++double gsl_cdf_weibull_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_weibull_Pinv (const double P, const double a, const double b); ++double gsl_cdf_weibull_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_pareto_P (const double x, const double a, const double b); ++double gsl_cdf_pareto_Q (const double x, const double a, const double b); ++ ++double gsl_cdf_pareto_Pinv (const double P, const double a, const double b); ++double gsl_cdf_pareto_Qinv (const double Q, const double a, const double b); ++ ++double gsl_cdf_logistic_P (const double x, const double a); ++double gsl_cdf_logistic_Q (const double x, const double a); ++ ++double gsl_cdf_logistic_Pinv (const double P, const double a); ++double gsl_cdf_logistic_Qinv (const double Q, const double a); ++ ++double gsl_cdf_binomial_P (const unsigned int k, const double p, const unsigned int n); ++double gsl_cdf_binomial_Q (const unsigned int k, const double p, const unsigned int n); ++ ++double gsl_cdf_poisson_P (const unsigned int k, const double mu); ++double gsl_cdf_poisson_Q (const unsigned int k, const double mu); ++ ++double gsl_cdf_geometric_P (const unsigned int k, const double p); ++double gsl_cdf_geometric_Q (const unsigned int k, const double p); ++ ++double gsl_cdf_negative_binomial_P (const unsigned int k, const double p, const double n); ++double gsl_cdf_negative_binomial_Q (const unsigned int k, const double p, const double n); ++ ++double gsl_cdf_pascal_P (const unsigned int k, const double p, const unsigned int n); ++double gsl_cdf_pascal_Q (const unsigned int k, const double p, const unsigned int n); ++ ++double gsl_cdf_hypergeometric_P (const unsigned int k, const unsigned int n1, ++ const unsigned int n2, const unsigned int t); ++double gsl_cdf_hypergeometric_Q (const unsigned int k, const unsigned int n1, ++ const unsigned int n2, const unsigned int t); ++ ++__END_DECLS ++ ++#endif /* __GSL_CDF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_COMPLEX_FLOAT_H__ ++#define __GSL_PERMUTE_COMPLEX_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_complex_float (const size_t * p, float * data, const size_t stride, const size_t n); ++int gsl_permute_complex_float_inverse (const size_t * p, float * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h (revision 14078) +@@ -0,0 +1,130 @@ ++/* multifit/gsl_multifit.h ++ * ++ * Copyright (C) 2000, 2007, 2010 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MULTIFIT_H__ ++#define __GSL_MULTIFIT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t n; /* number of observations */ ++ size_t p; /* number of parameters */ ++ gsl_matrix * A; ++ gsl_matrix * Q; ++ gsl_matrix * QSI; ++ gsl_vector * S; ++ gsl_vector * t; ++ gsl_vector * xt; ++ gsl_vector * D; ++} ++gsl_multifit_linear_workspace; ++ ++gsl_multifit_linear_workspace * ++gsl_multifit_linear_alloc (size_t n, size_t p); ++ ++void ++gsl_multifit_linear_free (gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_linear (const gsl_matrix * X, ++ const gsl_vector * y, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double * chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_linear_svd (const gsl_matrix * X, ++ const gsl_vector * y, ++ double tol, ++ size_t * rank, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double *chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_linear_usvd (const gsl_matrix * X, ++ const gsl_vector * y, ++ double tol, ++ size_t * rank, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double *chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_wlinear (const gsl_matrix * X, ++ const gsl_vector * w, ++ const gsl_vector * y, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double * chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_wlinear_svd (const gsl_matrix * X, ++ const gsl_vector * w, ++ const gsl_vector * y, ++ double tol, ++ size_t * rank, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double *chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_wlinear_usvd (const gsl_matrix * X, ++ const gsl_vector * w, ++ const gsl_vector * y, ++ double tol, ++ size_t * rank, ++ gsl_vector * c, ++ gsl_matrix * cov, ++ double *chisq, ++ gsl_multifit_linear_workspace * work); ++ ++int ++gsl_multifit_linear_est (const gsl_vector * x, ++ const gsl_vector * c, ++ const gsl_matrix * cov, double *y, double *y_err); ++ ++int ++gsl_multifit_linear_residuals (const gsl_matrix *X, const gsl_vector *y, ++ const gsl_vector *c, gsl_vector *r); ++ ++__END_DECLS ++ ++#endif /* __GSL_MULTIFIT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h (revision 14078) +@@ -0,0 +1,226 @@ ++/* multimin/gsl_multimin.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Fabrice Rossi ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Modified by Tuomo Keskitalo to include fminimizer and ++ Nelder Mead related lines */ ++ ++#ifndef __GSL_MULTIMIN_H__ ++#define __GSL_MULTIMIN_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Definition of an arbitrary real-valued function with gsl_vector input and */ ++/* parameters */ ++struct gsl_multimin_function_struct ++{ ++ double (* f) (const gsl_vector * x, void * params); ++ size_t n; ++ void * params; ++}; ++ ++typedef struct gsl_multimin_function_struct gsl_multimin_function; ++ ++#define GSL_MULTIMIN_FN_EVAL(F,x) (*((F)->f))(x,(F)->params) ++ ++/* Definition of an arbitrary differentiable real-valued function */ ++/* with gsl_vector input and parameters */ ++struct gsl_multimin_function_fdf_struct ++{ ++ double (* f) (const gsl_vector * x, void * params); ++ void (* df) (const gsl_vector * x, void * params,gsl_vector * df); ++ void (* fdf) (const gsl_vector * x, void * params,double *f,gsl_vector * df); ++ size_t n; ++ void * params; ++}; ++ ++typedef struct gsl_multimin_function_fdf_struct gsl_multimin_function_fdf; ++ ++#define GSL_MULTIMIN_FN_EVAL_F(F,x) (*((F)->f))(x,(F)->params) ++#define GSL_MULTIMIN_FN_EVAL_DF(F,x,g) (*((F)->df))(x,(F)->params,(g)) ++#define GSL_MULTIMIN_FN_EVAL_F_DF(F,x,y,g) (*((F)->fdf))(x,(F)->params,(y),(g)) ++ ++int gsl_multimin_diff (const gsl_multimin_function * f, ++ const gsl_vector * x, gsl_vector * g); ++ ++/* minimization of non-differentiable functions */ ++ ++typedef struct ++{ ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n); ++ int (*set) (void *state, gsl_multimin_function * f, ++ const gsl_vector * x, ++ double * size, ++ const gsl_vector * step_size); ++ int (*iterate) (void *state, gsl_multimin_function * f, ++ gsl_vector * x, ++ double * size, ++ double * fval); ++ void (*free) (void *state); ++} ++gsl_multimin_fminimizer_type; ++ ++typedef struct ++{ ++ /* multi dimensional part */ ++ const gsl_multimin_fminimizer_type *type; ++ gsl_multimin_function *f; ++ ++ double fval; ++ gsl_vector * x; ++ ++ double size; ++ ++ void *state; ++} ++gsl_multimin_fminimizer; ++ ++gsl_multimin_fminimizer * ++gsl_multimin_fminimizer_alloc(const gsl_multimin_fminimizer_type *T, ++ size_t n); ++ ++int ++gsl_multimin_fminimizer_set (gsl_multimin_fminimizer * s, ++ gsl_multimin_function * f, ++ const gsl_vector * x, ++ const gsl_vector * step_size); ++ ++void ++gsl_multimin_fminimizer_free(gsl_multimin_fminimizer *s); ++ ++const char * ++gsl_multimin_fminimizer_name (const gsl_multimin_fminimizer * s); ++ ++int ++gsl_multimin_fminimizer_iterate(gsl_multimin_fminimizer *s); ++ ++gsl_vector * ++gsl_multimin_fminimizer_x (const gsl_multimin_fminimizer * s); ++ ++double ++gsl_multimin_fminimizer_minimum (const gsl_multimin_fminimizer * s); ++ ++double ++gsl_multimin_fminimizer_size (const gsl_multimin_fminimizer * s); ++ ++/* Convergence test functions */ ++ ++int ++gsl_multimin_test_gradient(const gsl_vector * g, double epsabs); ++ ++int ++gsl_multimin_test_size(const double size, double epsabs); ++ ++/* minimisation of differentiable functions */ ++ ++typedef struct ++{ ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n); ++ int (*set) (void *state, gsl_multimin_function_fdf * fdf, ++ const gsl_vector * x, double * f, ++ gsl_vector * gradient, double step_size, double tol); ++ int (*iterate) (void *state,gsl_multimin_function_fdf * fdf, ++ gsl_vector * x, double * f, ++ gsl_vector * gradient, gsl_vector * dx); ++ int (*restart) (void *state); ++ void (*free) (void *state); ++} ++gsl_multimin_fdfminimizer_type; ++ ++typedef struct ++{ ++ /* multi dimensional part */ ++ const gsl_multimin_fdfminimizer_type *type; ++ gsl_multimin_function_fdf *fdf; ++ ++ double f; ++ gsl_vector * x; ++ gsl_vector * gradient; ++ gsl_vector * dx; ++ ++ void *state; ++} ++gsl_multimin_fdfminimizer; ++ ++gsl_multimin_fdfminimizer * ++gsl_multimin_fdfminimizer_alloc(const gsl_multimin_fdfminimizer_type *T, ++ size_t n); ++ ++int ++gsl_multimin_fdfminimizer_set (gsl_multimin_fdfminimizer * s, ++ gsl_multimin_function_fdf *fdf, ++ const gsl_vector * x, ++ double step_size, double tol); ++ ++void ++gsl_multimin_fdfminimizer_free(gsl_multimin_fdfminimizer *s); ++ ++const char * ++gsl_multimin_fdfminimizer_name (const gsl_multimin_fdfminimizer * s); ++ ++int ++gsl_multimin_fdfminimizer_iterate(gsl_multimin_fdfminimizer *s); ++ ++int ++gsl_multimin_fdfminimizer_restart(gsl_multimin_fdfminimizer *s); ++ ++gsl_vector * ++gsl_multimin_fdfminimizer_x (const gsl_multimin_fdfminimizer * s); ++ ++gsl_vector * ++gsl_multimin_fdfminimizer_dx (const gsl_multimin_fdfminimizer * s); ++ ++gsl_vector * ++gsl_multimin_fdfminimizer_gradient (const gsl_multimin_fdfminimizer * s); ++ ++double ++gsl_multimin_fdfminimizer_minimum (const gsl_multimin_fdfminimizer * s); ++ ++GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_steepest_descent; ++GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_conjugate_pr; ++GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_conjugate_fr; ++GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_vector_bfgs; ++GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_vector_bfgs2; ++GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex; ++GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex2; ++GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex2rand; ++ ++__END_DECLS ++ ++#endif /* __GSL_MULTIMIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_DOUBLE_H__ ++#define __GSL_MATRIX_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ double * data; ++ gsl_block * block; ++ int owner; ++} gsl_matrix; ++ ++typedef struct ++{ ++ gsl_matrix matrix; ++} _gsl_matrix_view; ++ ++typedef _gsl_matrix_view gsl_matrix_view; ++ ++typedef struct ++{ ++ gsl_matrix matrix; ++} _gsl_matrix_const_view; ++ ++typedef const _gsl_matrix_const_view gsl_matrix_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix * ++gsl_matrix_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix * ++gsl_matrix_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix * ++gsl_matrix_alloc_from_block (gsl_block * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix * ++gsl_matrix_alloc_from_matrix (gsl_matrix * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector * ++gsl_vector_alloc_row_from_matrix (gsl_matrix * m, ++ const size_t i); ++ ++gsl_vector * ++gsl_vector_alloc_col_from_matrix (gsl_matrix * m, ++ const size_t j); ++ ++void gsl_matrix_free (gsl_matrix * m); ++ ++/* Views */ ++ ++_gsl_matrix_view ++gsl_matrix_submatrix (gsl_matrix * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_view ++gsl_matrix_row (gsl_matrix * m, const size_t i); ++ ++_gsl_vector_view ++gsl_matrix_column (gsl_matrix * m, const size_t j); ++ ++_gsl_vector_view ++gsl_matrix_diagonal (gsl_matrix * m); ++ ++_gsl_vector_view ++gsl_matrix_subdiagonal (gsl_matrix * m, const size_t k); ++ ++_gsl_vector_view ++gsl_matrix_superdiagonal (gsl_matrix * m, const size_t k); ++ ++_gsl_vector_view ++gsl_matrix_subrow (gsl_matrix * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_view ++gsl_matrix_subcolumn (gsl_matrix * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_view ++gsl_matrix_view_array (double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_view ++gsl_matrix_view_array_with_tda (double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_view ++gsl_matrix_view_vector (gsl_vector * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_view ++gsl_matrix_view_vector_with_tda (gsl_vector * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_const_view ++gsl_matrix_const_submatrix (const gsl_matrix * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_const_view ++gsl_matrix_const_row (const gsl_matrix * m, ++ const size_t i); ++ ++_gsl_vector_const_view ++gsl_matrix_const_column (const gsl_matrix * m, ++ const size_t j); ++ ++_gsl_vector_const_view ++gsl_matrix_const_diagonal (const gsl_matrix * m); ++ ++_gsl_vector_const_view ++gsl_matrix_const_subdiagonal (const gsl_matrix * m, ++ const size_t k); ++ ++_gsl_vector_const_view ++gsl_matrix_const_superdiagonal (const gsl_matrix * m, ++ const size_t k); ++ ++_gsl_vector_const_view ++gsl_matrix_const_subrow (const gsl_matrix * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_const_view ++gsl_matrix_const_subcolumn (const gsl_matrix * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_const_view ++gsl_matrix_const_view_array (const double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_const_view ++gsl_matrix_const_view_array_with_tda (const double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_const_view ++gsl_matrix_const_view_vector (const gsl_vector * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_const_view ++gsl_matrix_const_view_vector_with_tda (const gsl_vector * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_set_zero (gsl_matrix * m); ++void gsl_matrix_set_identity (gsl_matrix * m); ++void gsl_matrix_set_all (gsl_matrix * m, double x); ++ ++int gsl_matrix_fread (FILE * stream, gsl_matrix * m) ; ++int gsl_matrix_fwrite (FILE * stream, const gsl_matrix * m) ; ++int gsl_matrix_fscanf (FILE * stream, gsl_matrix * m); ++int gsl_matrix_fprintf (FILE * stream, const gsl_matrix * m, const char * format); ++ ++int gsl_matrix_memcpy(gsl_matrix * dest, const gsl_matrix * src); ++int gsl_matrix_swap(gsl_matrix * m1, gsl_matrix * m2); ++ ++int gsl_matrix_swap_rows(gsl_matrix * m, const size_t i, const size_t j); ++int gsl_matrix_swap_columns(gsl_matrix * m, const size_t i, const size_t j); ++int gsl_matrix_swap_rowcol(gsl_matrix * m, const size_t i, const size_t j); ++int gsl_matrix_transpose (gsl_matrix * m); ++int gsl_matrix_transpose_memcpy (gsl_matrix * dest, const gsl_matrix * src); ++ ++double gsl_matrix_max (const gsl_matrix * m); ++double gsl_matrix_min (const gsl_matrix * m); ++void gsl_matrix_minmax (const gsl_matrix * m, double * min_out, double * max_out); ++ ++void gsl_matrix_max_index (const gsl_matrix * m, size_t * imax, size_t *jmax); ++void gsl_matrix_min_index (const gsl_matrix * m, size_t * imin, size_t *jmin); ++void gsl_matrix_minmax_index (const gsl_matrix * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_equal (const gsl_matrix * a, const gsl_matrix * b); ++ ++int gsl_matrix_isnull (const gsl_matrix * m); ++int gsl_matrix_ispos (const gsl_matrix * m); ++int gsl_matrix_isneg (const gsl_matrix * m); ++int gsl_matrix_isnonneg (const gsl_matrix * m); ++ ++int gsl_matrix_add (gsl_matrix * a, const gsl_matrix * b); ++int gsl_matrix_sub (gsl_matrix * a, const gsl_matrix * b); ++int gsl_matrix_mul_elements (gsl_matrix * a, const gsl_matrix * b); ++int gsl_matrix_div_elements (gsl_matrix * a, const gsl_matrix * b); ++int gsl_matrix_scale (gsl_matrix * a, const double x); ++int gsl_matrix_add_constant (gsl_matrix * a, const double x); ++int gsl_matrix_add_diagonal (gsl_matrix * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_get_row(gsl_vector * v, const gsl_matrix * m, const size_t i); ++int gsl_matrix_get_col(gsl_vector * v, const gsl_matrix * m, const size_t j); ++int gsl_matrix_set_row(gsl_matrix * m, const size_t i, const gsl_vector * v); ++int gsl_matrix_set_col(gsl_matrix * m, const size_t j, const gsl_vector * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL double gsl_matrix_get(const gsl_matrix * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_set(gsl_matrix * m, const size_t i, const size_t j, const double x); ++INLINE_DECL double * gsl_matrix_ptr(gsl_matrix * m, const size_t i, const size_t j); ++INLINE_DECL const double * gsl_matrix_const_ptr(const gsl_matrix * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++double ++gsl_matrix_get(const gsl_matrix * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_set(gsl_matrix * m, const size_t i, const size_t j, const double x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++double * ++gsl_matrix_ptr(gsl_matrix * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (double *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const double * ++gsl_matrix_const_ptr(const gsl_matrix * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const double *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h (revision 14078) +@@ -0,0 +1,122 @@ ++/* const/gsl_const_cgsm.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, ++ * 2006, 2007, 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST_CGSM__ ++#define __GSL_CONST_CGSM__ ++ ++#define GSL_CONST_CGSM_SPEED_OF_LIGHT (2.99792458e10) /* cm / s */ ++#define GSL_CONST_CGSM_GRAVITATIONAL_CONSTANT (6.673e-8) /* cm^3 / g s^2 */ ++#define GSL_CONST_CGSM_PLANCKS_CONSTANT_H (6.62606896e-27) /* g cm^2 / s */ ++#define GSL_CONST_CGSM_PLANCKS_CONSTANT_HBAR (1.05457162825e-27) /* g cm^2 / s */ ++#define GSL_CONST_CGSM_ASTRONOMICAL_UNIT (1.49597870691e13) /* cm */ ++#define GSL_CONST_CGSM_LIGHT_YEAR (9.46053620707e17) /* cm */ ++#define GSL_CONST_CGSM_PARSEC (3.08567758135e18) /* cm */ ++#define GSL_CONST_CGSM_GRAV_ACCEL (9.80665e2) /* cm / s^2 */ ++#define GSL_CONST_CGSM_ELECTRON_VOLT (1.602176487e-12) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_MASS_ELECTRON (9.10938188e-28) /* g */ ++#define GSL_CONST_CGSM_MASS_MUON (1.88353109e-25) /* g */ ++#define GSL_CONST_CGSM_MASS_PROTON (1.67262158e-24) /* g */ ++#define GSL_CONST_CGSM_MASS_NEUTRON (1.67492716e-24) /* g */ ++#define GSL_CONST_CGSM_RYDBERG (2.17987196968e-11) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_BOLTZMANN (1.3806504e-16) /* g cm^2 / K s^2 */ ++#define GSL_CONST_CGSM_MOLAR_GAS (8.314472e7) /* g cm^2 / K mol s^2 */ ++#define GSL_CONST_CGSM_STANDARD_GAS_VOLUME (2.2710981e4) /* cm^3 / mol */ ++#define GSL_CONST_CGSM_MINUTE (6e1) /* s */ ++#define GSL_CONST_CGSM_HOUR (3.6e3) /* s */ ++#define GSL_CONST_CGSM_DAY (8.64e4) /* s */ ++#define GSL_CONST_CGSM_WEEK (6.048e5) /* s */ ++#define GSL_CONST_CGSM_INCH (2.54e0) /* cm */ ++#define GSL_CONST_CGSM_FOOT (3.048e1) /* cm */ ++#define GSL_CONST_CGSM_YARD (9.144e1) /* cm */ ++#define GSL_CONST_CGSM_MILE (1.609344e5) /* cm */ ++#define GSL_CONST_CGSM_NAUTICAL_MILE (1.852e5) /* cm */ ++#define GSL_CONST_CGSM_FATHOM (1.8288e2) /* cm */ ++#define GSL_CONST_CGSM_MIL (2.54e-3) /* cm */ ++#define GSL_CONST_CGSM_POINT (3.52777777778e-2) /* cm */ ++#define GSL_CONST_CGSM_TEXPOINT (3.51459803515e-2) /* cm */ ++#define GSL_CONST_CGSM_MICRON (1e-4) /* cm */ ++#define GSL_CONST_CGSM_ANGSTROM (1e-8) /* cm */ ++#define GSL_CONST_CGSM_HECTARE (1e8) /* cm^2 */ ++#define GSL_CONST_CGSM_ACRE (4.04685642241e7) /* cm^2 */ ++#define GSL_CONST_CGSM_BARN (1e-24) /* cm^2 */ ++#define GSL_CONST_CGSM_LITER (1e3) /* cm^3 */ ++#define GSL_CONST_CGSM_US_GALLON (3.78541178402e3) /* cm^3 */ ++#define GSL_CONST_CGSM_QUART (9.46352946004e2) /* cm^3 */ ++#define GSL_CONST_CGSM_PINT (4.73176473002e2) /* cm^3 */ ++#define GSL_CONST_CGSM_CUP (2.36588236501e2) /* cm^3 */ ++#define GSL_CONST_CGSM_FLUID_OUNCE (2.95735295626e1) /* cm^3 */ ++#define GSL_CONST_CGSM_TABLESPOON (1.47867647813e1) /* cm^3 */ ++#define GSL_CONST_CGSM_TEASPOON (4.92892159375e0) /* cm^3 */ ++#define GSL_CONST_CGSM_CANADIAN_GALLON (4.54609e3) /* cm^3 */ ++#define GSL_CONST_CGSM_UK_GALLON (4.546092e3) /* cm^3 */ ++#define GSL_CONST_CGSM_MILES_PER_HOUR (4.4704e1) /* cm / s */ ++#define GSL_CONST_CGSM_KILOMETERS_PER_HOUR (2.77777777778e1) /* cm / s */ ++#define GSL_CONST_CGSM_KNOT (5.14444444444e1) /* cm / s */ ++#define GSL_CONST_CGSM_POUND_MASS (4.5359237e2) /* g */ ++#define GSL_CONST_CGSM_OUNCE_MASS (2.8349523125e1) /* g */ ++#define GSL_CONST_CGSM_TON (9.0718474e5) /* g */ ++#define GSL_CONST_CGSM_METRIC_TON (1e6) /* g */ ++#define GSL_CONST_CGSM_UK_TON (1.0160469088e6) /* g */ ++#define GSL_CONST_CGSM_TROY_OUNCE (3.1103475e1) /* g */ ++#define GSL_CONST_CGSM_CARAT (2e-1) /* g */ ++#define GSL_CONST_CGSM_UNIFIED_ATOMIC_MASS (1.660538782e-24) /* g */ ++#define GSL_CONST_CGSM_GRAM_FORCE (9.80665e2) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_POUND_FORCE (4.44822161526e5) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_KILOPOUND_FORCE (4.44822161526e8) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_POUNDAL (1.38255e4) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_CALORIE (4.1868e7) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_BTU (1.05505585262e10) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_THERM (1.05506e15) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_HORSEPOWER (7.457e9) /* g cm^2 / s^3 */ ++#define GSL_CONST_CGSM_BAR (1e6) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_STD_ATMOSPHERE (1.01325e6) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_TORR (1.33322368421e3) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_METER_OF_MERCURY (1.33322368421e6) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_INCH_OF_MERCURY (3.38638815789e4) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_INCH_OF_WATER (2.490889e3) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_PSI (6.89475729317e4) /* g / cm s^2 */ ++#define GSL_CONST_CGSM_POISE (1e0) /* g / cm s */ ++#define GSL_CONST_CGSM_STOKES (1e0) /* cm^2 / s */ ++#define GSL_CONST_CGSM_STILB (1e0) /* cd / cm^2 */ ++#define GSL_CONST_CGSM_LUMEN (1e0) /* cd sr */ ++#define GSL_CONST_CGSM_LUX (1e-4) /* cd sr / cm^2 */ ++#define GSL_CONST_CGSM_PHOT (1e0) /* cd sr / cm^2 */ ++#define GSL_CONST_CGSM_FOOTCANDLE (1.076e-3) /* cd sr / cm^2 */ ++#define GSL_CONST_CGSM_LAMBERT (1e0) /* cd sr / cm^2 */ ++#define GSL_CONST_CGSM_FOOTLAMBERT (1.07639104e-3) /* cd sr / cm^2 */ ++#define GSL_CONST_CGSM_CURIE (3.7e10) /* 1 / s */ ++#define GSL_CONST_CGSM_ROENTGEN (2.58e-8) /* abamp s / g */ ++#define GSL_CONST_CGSM_RAD (1e2) /* cm^2 / s^2 */ ++#define GSL_CONST_CGSM_SOLAR_MASS (1.98892e33) /* g */ ++#define GSL_CONST_CGSM_BOHR_RADIUS (5.291772083e-9) /* cm */ ++#define GSL_CONST_CGSM_NEWTON (1e5) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_DYNE (1e0) /* cm g / s^2 */ ++#define GSL_CONST_CGSM_JOULE (1e7) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_ERG (1e0) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGSM_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-5) /* g / K^4 s^3 */ ++#define GSL_CONST_CGSM_THOMSON_CROSS_SECTION (6.65245893699e-25) /* cm^2 */ ++#define GSL_CONST_CGSM_BOHR_MAGNETON (9.27400899e-21) /* abamp cm^2 */ ++#define GSL_CONST_CGSM_NUCLEAR_MAGNETON (5.05078317e-24) /* abamp cm^2 */ ++#define GSL_CONST_CGSM_ELECTRON_MAGNETIC_MOMENT (9.28476362e-21) /* abamp cm^2 */ ++#define GSL_CONST_CGSM_PROTON_MAGNETIC_MOMENT (1.410606633e-23) /* abamp cm^2 */ ++#define GSL_CONST_CGSM_FARADAY (9.64853429775e3) /* abamp s / mol */ ++#define GSL_CONST_CGSM_ELECTRON_CHARGE (1.602176487e-20) /* abamp s */ ++ ++#endif /* __GSL_CONST_CGSM__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_CHAR_H__ ++#define __GSL_MATRIX_CHAR_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ char * data; ++ gsl_block_char * block; ++ int owner; ++} gsl_matrix_char; ++ ++typedef struct ++{ ++ gsl_matrix_char matrix; ++} _gsl_matrix_char_view; ++ ++typedef _gsl_matrix_char_view gsl_matrix_char_view; ++ ++typedef struct ++{ ++ gsl_matrix_char matrix; ++} _gsl_matrix_char_const_view; ++ ++typedef const _gsl_matrix_char_const_view gsl_matrix_char_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_char * ++gsl_matrix_char_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_char * ++gsl_matrix_char_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_char * ++gsl_matrix_char_alloc_from_block (gsl_block_char * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_char * ++gsl_matrix_char_alloc_from_matrix (gsl_matrix_char * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_char * ++gsl_vector_char_alloc_row_from_matrix (gsl_matrix_char * m, ++ const size_t i); ++ ++gsl_vector_char * ++gsl_vector_char_alloc_col_from_matrix (gsl_matrix_char * m, ++ const size_t j); ++ ++void gsl_matrix_char_free (gsl_matrix_char * m); ++ ++/* Views */ ++ ++_gsl_matrix_char_view ++gsl_matrix_char_submatrix (gsl_matrix_char * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_char_view ++gsl_matrix_char_row (gsl_matrix_char * m, const size_t i); ++ ++_gsl_vector_char_view ++gsl_matrix_char_column (gsl_matrix_char * m, const size_t j); ++ ++_gsl_vector_char_view ++gsl_matrix_char_diagonal (gsl_matrix_char * m); ++ ++_gsl_vector_char_view ++gsl_matrix_char_subdiagonal (gsl_matrix_char * m, const size_t k); ++ ++_gsl_vector_char_view ++gsl_matrix_char_superdiagonal (gsl_matrix_char * m, const size_t k); ++ ++_gsl_vector_char_view ++gsl_matrix_char_subrow (gsl_matrix_char * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_char_view ++gsl_matrix_char_subcolumn (gsl_matrix_char * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_char_view ++gsl_matrix_char_view_array (char * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_char_view ++gsl_matrix_char_view_array_with_tda (char * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_char_view ++gsl_matrix_char_view_vector (gsl_vector_char * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_char_view ++gsl_matrix_char_view_vector_with_tda (gsl_vector_char * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_char_const_view ++gsl_matrix_char_const_submatrix (const gsl_matrix_char * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_row (const gsl_matrix_char * m, ++ const size_t i); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_column (const gsl_matrix_char * m, ++ const size_t j); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_diagonal (const gsl_matrix_char * m); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_subdiagonal (const gsl_matrix_char * m, ++ const size_t k); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_superdiagonal (const gsl_matrix_char * m, ++ const size_t k); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_subrow (const gsl_matrix_char * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_char_const_view ++gsl_matrix_char_const_subcolumn (const gsl_matrix_char * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_char_const_view ++gsl_matrix_char_const_view_array (const char * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_char_const_view ++gsl_matrix_char_const_view_array_with_tda (const char * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_char_const_view ++gsl_matrix_char_const_view_vector (const gsl_vector_char * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_char_const_view ++gsl_matrix_char_const_view_vector_with_tda (const gsl_vector_char * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_char_set_zero (gsl_matrix_char * m); ++void gsl_matrix_char_set_identity (gsl_matrix_char * m); ++void gsl_matrix_char_set_all (gsl_matrix_char * m, char x); ++ ++int gsl_matrix_char_fread (FILE * stream, gsl_matrix_char * m) ; ++int gsl_matrix_char_fwrite (FILE * stream, const gsl_matrix_char * m) ; ++int gsl_matrix_char_fscanf (FILE * stream, gsl_matrix_char * m); ++int gsl_matrix_char_fprintf (FILE * stream, const gsl_matrix_char * m, const char * format); ++ ++int gsl_matrix_char_memcpy(gsl_matrix_char * dest, const gsl_matrix_char * src); ++int gsl_matrix_char_swap(gsl_matrix_char * m1, gsl_matrix_char * m2); ++ ++int gsl_matrix_char_swap_rows(gsl_matrix_char * m, const size_t i, const size_t j); ++int gsl_matrix_char_swap_columns(gsl_matrix_char * m, const size_t i, const size_t j); ++int gsl_matrix_char_swap_rowcol(gsl_matrix_char * m, const size_t i, const size_t j); ++int gsl_matrix_char_transpose (gsl_matrix_char * m); ++int gsl_matrix_char_transpose_memcpy (gsl_matrix_char * dest, const gsl_matrix_char * src); ++ ++char gsl_matrix_char_max (const gsl_matrix_char * m); ++char gsl_matrix_char_min (const gsl_matrix_char * m); ++void gsl_matrix_char_minmax (const gsl_matrix_char * m, char * min_out, char * max_out); ++ ++void gsl_matrix_char_max_index (const gsl_matrix_char * m, size_t * imax, size_t *jmax); ++void gsl_matrix_char_min_index (const gsl_matrix_char * m, size_t * imin, size_t *jmin); ++void gsl_matrix_char_minmax_index (const gsl_matrix_char * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_char_equal (const gsl_matrix_char * a, const gsl_matrix_char * b); ++ ++int gsl_matrix_char_isnull (const gsl_matrix_char * m); ++int gsl_matrix_char_ispos (const gsl_matrix_char * m); ++int gsl_matrix_char_isneg (const gsl_matrix_char * m); ++int gsl_matrix_char_isnonneg (const gsl_matrix_char * m); ++ ++int gsl_matrix_char_add (gsl_matrix_char * a, const gsl_matrix_char * b); ++int gsl_matrix_char_sub (gsl_matrix_char * a, const gsl_matrix_char * b); ++int gsl_matrix_char_mul_elements (gsl_matrix_char * a, const gsl_matrix_char * b); ++int gsl_matrix_char_div_elements (gsl_matrix_char * a, const gsl_matrix_char * b); ++int gsl_matrix_char_scale (gsl_matrix_char * a, const double x); ++int gsl_matrix_char_add_constant (gsl_matrix_char * a, const double x); ++int gsl_matrix_char_add_diagonal (gsl_matrix_char * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_char_get_row(gsl_vector_char * v, const gsl_matrix_char * m, const size_t i); ++int gsl_matrix_char_get_col(gsl_vector_char * v, const gsl_matrix_char * m, const size_t j); ++int gsl_matrix_char_set_row(gsl_matrix_char * m, const size_t i, const gsl_vector_char * v); ++int gsl_matrix_char_set_col(gsl_matrix_char * m, const size_t j, const gsl_vector_char * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL char gsl_matrix_char_get(const gsl_matrix_char * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_char_set(gsl_matrix_char * m, const size_t i, const size_t j, const char x); ++INLINE_DECL char * gsl_matrix_char_ptr(gsl_matrix_char * m, const size_t i, const size_t j); ++INLINE_DECL const char * gsl_matrix_char_const_ptr(const gsl_matrix_char * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++char ++gsl_matrix_char_get(const gsl_matrix_char * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_char_set(gsl_matrix_char * m, const size_t i, const size_t j, const char x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++char * ++gsl_matrix_char_ptr(gsl_matrix_char * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (char *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const char * ++gsl_matrix_char_const_ptr(const gsl_matrix_char * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const char *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_UINT_H__ ++#define __GSL_VECTOR_UINT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ unsigned int *data; ++ gsl_block_uint *block; ++ int owner; ++} ++gsl_vector_uint; ++ ++typedef struct ++{ ++ gsl_vector_uint vector; ++} _gsl_vector_uint_view; ++ ++typedef _gsl_vector_uint_view gsl_vector_uint_view; ++ ++typedef struct ++{ ++ gsl_vector_uint vector; ++} _gsl_vector_uint_const_view; ++ ++typedef const _gsl_vector_uint_const_view gsl_vector_uint_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_uint *gsl_vector_uint_alloc (const size_t n); ++gsl_vector_uint *gsl_vector_uint_calloc (const size_t n); ++ ++gsl_vector_uint *gsl_vector_uint_alloc_from_block (gsl_block_uint * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_uint *gsl_vector_uint_alloc_from_vector (gsl_vector_uint * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_uint_free (gsl_vector_uint * v); ++ ++/* Views */ ++ ++_gsl_vector_uint_view ++gsl_vector_uint_view_array (unsigned int *v, size_t n); ++ ++_gsl_vector_uint_view ++gsl_vector_uint_view_array_with_stride (unsigned int *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uint_const_view ++gsl_vector_uint_const_view_array (const unsigned int *v, size_t n); ++ ++_gsl_vector_uint_const_view ++gsl_vector_uint_const_view_array_with_stride (const unsigned int *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uint_view ++gsl_vector_uint_subvector (gsl_vector_uint *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_uint_view ++gsl_vector_uint_subvector_with_stride (gsl_vector_uint *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_uint_const_view ++gsl_vector_uint_const_subvector (const gsl_vector_uint *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_uint_const_view ++gsl_vector_uint_const_subvector_with_stride (const gsl_vector_uint *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_uint_set_zero (gsl_vector_uint * v); ++void gsl_vector_uint_set_all (gsl_vector_uint * v, unsigned int x); ++int gsl_vector_uint_set_basis (gsl_vector_uint * v, size_t i); ++ ++int gsl_vector_uint_fread (FILE * stream, gsl_vector_uint * v); ++int gsl_vector_uint_fwrite (FILE * stream, const gsl_vector_uint * v); ++int gsl_vector_uint_fscanf (FILE * stream, gsl_vector_uint * v); ++int gsl_vector_uint_fprintf (FILE * stream, const gsl_vector_uint * v, ++ const char *format); ++ ++int gsl_vector_uint_memcpy (gsl_vector_uint * dest, const gsl_vector_uint * src); ++ ++int gsl_vector_uint_reverse (gsl_vector_uint * v); ++ ++int gsl_vector_uint_swap (gsl_vector_uint * v, gsl_vector_uint * w); ++int gsl_vector_uint_swap_elements (gsl_vector_uint * v, const size_t i, const size_t j); ++ ++unsigned int gsl_vector_uint_max (const gsl_vector_uint * v); ++unsigned int gsl_vector_uint_min (const gsl_vector_uint * v); ++void gsl_vector_uint_minmax (const gsl_vector_uint * v, unsigned int * min_out, unsigned int * max_out); ++ ++size_t gsl_vector_uint_max_index (const gsl_vector_uint * v); ++size_t gsl_vector_uint_min_index (const gsl_vector_uint * v); ++void gsl_vector_uint_minmax_index (const gsl_vector_uint * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_uint_add (gsl_vector_uint * a, const gsl_vector_uint * b); ++int gsl_vector_uint_sub (gsl_vector_uint * a, const gsl_vector_uint * b); ++int gsl_vector_uint_mul (gsl_vector_uint * a, const gsl_vector_uint * b); ++int gsl_vector_uint_div (gsl_vector_uint * a, const gsl_vector_uint * b); ++int gsl_vector_uint_scale (gsl_vector_uint * a, const double x); ++int gsl_vector_uint_add_constant (gsl_vector_uint * a, const double x); ++ ++int gsl_vector_uint_equal (const gsl_vector_uint * u, ++ const gsl_vector_uint * v); ++ ++int gsl_vector_uint_isnull (const gsl_vector_uint * v); ++int gsl_vector_uint_ispos (const gsl_vector_uint * v); ++int gsl_vector_uint_isneg (const gsl_vector_uint * v); ++int gsl_vector_uint_isnonneg (const gsl_vector_uint * v); ++ ++INLINE_DECL unsigned int gsl_vector_uint_get (const gsl_vector_uint * v, const size_t i); ++INLINE_DECL void gsl_vector_uint_set (gsl_vector_uint * v, const size_t i, unsigned int x); ++INLINE_DECL unsigned int * gsl_vector_uint_ptr (gsl_vector_uint * v, const size_t i); ++INLINE_DECL const unsigned int * gsl_vector_uint_const_ptr (const gsl_vector_uint * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++unsigned int ++gsl_vector_uint_get (const gsl_vector_uint * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_uint_set (gsl_vector_uint * v, const size_t i, unsigned int x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++unsigned int * ++gsl_vector_uint_ptr (gsl_vector_uint * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (unsigned int *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const unsigned int * ++gsl_vector_uint_const_ptr (const gsl_vector_uint * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const unsigned int *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_UINT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_UINT_H__ ++#define __GSL_PERMUTE_VECTOR_UINT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_uint (const gsl_permutation * p, gsl_vector_uint * v); ++int gsl_permute_vector_uint_inverse (const gsl_permutation * p, gsl_vector_uint * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_complex_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ ++#define __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_complex_long_double (const gsl_permutation * p, gsl_vector_complex_long_double * v); ++int gsl_permute_vector_complex_long_double_inverse (const gsl_permutation * p, gsl_vector_complex_long_double * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_INT_H__ ++#define __GSL_STATISTICS_INT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_int_mean (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_variance (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_sd (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_variance_with_fixed_mean (const int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_int_sd_with_fixed_mean (const int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_int_tss (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_tss_m (const int data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_int_absdev (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_skew (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_kurtosis (const int data[], const size_t stride, const size_t n); ++double gsl_stats_int_lag1_autocorrelation (const int data[], const size_t stride, const size_t n); ++ ++double gsl_stats_int_covariance (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n); ++double gsl_stats_int_correlation (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_int_variance_m (const int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_int_sd_m (const int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_int_absdev_m (const int data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_int_skew_m_sd (const int data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_int_kurtosis_m_sd (const int data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_int_lag1_autocorrelation_m (const int data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_int_covariance_m (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_int_pvariance (const int data1[], const size_t stride1, const size_t n1, const int data2[], const size_t stride2, const size_t n2); ++double gsl_stats_int_ttest (const int data1[], const size_t stride1, const size_t n1, const int data2[], const size_t stride2, const size_t n2); ++ ++int gsl_stats_int_max (const int data[], const size_t stride, const size_t n); ++int gsl_stats_int_min (const int data[], const size_t stride, const size_t n); ++void gsl_stats_int_minmax (int * min, int * max, const int data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_int_max_index (const int data[], const size_t stride, const size_t n); ++size_t gsl_stats_int_min_index (const int data[], const size_t stride, const size_t n); ++void gsl_stats_int_minmax_index (size_t * min_index, size_t * max_index, const int data[], const size_t stride, const size_t n); ++ ++double gsl_stats_int_median_from_sorted_data (const int sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_int_quantile_from_sorted_data (const int sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h (revision 14078) +@@ -0,0 +1,41 @@ ++/* gsl_types.h ++ * ++ * Copyright (C) 2001, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_TYPES_H__ ++#define __GSL_TYPES_H__ ++ ++#ifndef GSL_VAR ++ ++#ifdef WIN32 ++# ifdef GSL_DLL ++# ifdef DLL_EXPORT ++# define GSL_VAR extern __declspec(dllexport) ++# else ++# define GSL_VAR extern __declspec(dllimport) ++# endif ++# else ++# define GSL_VAR extern ++# endif ++#else ++# define GSL_VAR extern ++#endif ++ ++#endif ++ ++#endif /* __GSL_TYPES_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* monte/gsl_monte_plain.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Plain Monte-Carlo. */ ++ ++/* Author: MJB */ ++ ++#ifndef __GSL_MONTE_PLAIN_H__ ++#define __GSL_MONTE_PLAIN_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct { ++ size_t dim; ++ double *x; ++} gsl_monte_plain_state; ++ ++int ++gsl_monte_plain_integrate (const gsl_monte_function * f, ++ const double xl[], const double xu[], ++ const size_t dim, ++ const size_t calls, ++ gsl_rng * r, ++ gsl_monte_plain_state * state, ++ double *result, double *abserr); ++ ++gsl_monte_plain_state* gsl_monte_plain_alloc(size_t dim); ++ ++int gsl_monte_plain_init(gsl_monte_plain_state* state); ++ ++void gsl_monte_plain_free (gsl_monte_plain_state* state); ++ ++__END_DECLS ++ ++#endif /* __GSL_MONTE_PLAIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h (revision 14078) +@@ -0,0 +1,549 @@ ++/* specfunc/gsl_sf_bessel.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_BESSEL_H__ ++#define __GSL_SF_BESSEL_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Regular Bessel Function J_0(x) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_bessel_J0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_J0(const double x); ++ ++ ++/* Regular Bessel Function J_1(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_J1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_J1(const double x); ++ ++ ++/* Regular Bessel Function J_n(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Jn_e(int n, double x, gsl_sf_result * result); ++double gsl_sf_bessel_Jn(const int n, const double x); ++ ++ ++/* Regular Bessel Function J_n(x), nmin <= n <= nmax ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Jn_array(int nmin, int nmax, double x, double * result_array); ++ ++ ++/* Irregular Bessel function Y_0(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Y0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Y0(const double x); ++ ++ ++/* Irregular Bessel function Y_1(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Y1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Y1(const double x); ++ ++ ++/* Irregular Bessel function Y_n(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Yn_e(int n,const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Yn(const int n,const double x); ++ ++ ++/* Irregular Bessel function Y_n(x), nmin <= n <= nmax ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Yn_array(const int nmin, const int nmax, const double x, double * result_array); ++ ++ ++/* Regular modified Bessel function I_0(x) ++ * ++ * exceptions: GSL_EOVRFLW ++ */ ++int gsl_sf_bessel_I0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_I0(const double x); ++ ++ ++/* Regular modified Bessel function I_1(x) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_I1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_I1(const double x); ++ ++ ++/* Regular modified Bessel function I_n(x) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_In_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_In(const int n, const double x); ++ ++ ++/* Regular modified Bessel function I_n(x) for n=nmin,...,nmax ++ * ++ * nmin >=0, nmax >= nmin ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_In_array(const int nmin, const int nmax, const double x, double * result_array); ++ ++ ++/* Scaled regular modified Bessel function ++ * exp(-|x|) I_0(x) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_bessel_I0_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_I0_scaled(const double x); ++ ++ ++/* Scaled regular modified Bessel function ++ * exp(-|x|) I_1(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_I1_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_I1_scaled(const double x); ++ ++ ++/* Scaled regular modified Bessel function ++ * exp(-|x|) I_n(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_In_scaled_e(int n, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_In_scaled(const int n, const double x); ++ ++ ++/* Scaled regular modified Bessel function ++ * exp(-|x|) I_n(x) for n=nmin,...,nmax ++ * ++ * nmin >=0, nmax >= nmin ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_In_scaled_array(const int nmin, const int nmax, const double x, double * result_array); ++ ++ ++/* Irregular modified Bessel function K_0(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_K0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_K0(const double x); ++ ++ ++/* Irregular modified Bessel function K_1(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_K1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_K1(const double x); ++ ++ ++/* Irregular modified Bessel function K_n(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Kn_e(const int n, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Kn(const int n, const double x); ++ ++ ++/* Irregular modified Bessel function K_n(x) for n=nmin,...,nmax ++ * ++ * x > 0.0, nmin >=0, nmax >= nmin ++ * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Kn_array(const int nmin, const int nmax, const double x, double * result_array); ++ ++ ++/* Scaled irregular modified Bessel function ++ * exp(x) K_0(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_bessel_K0_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_K0_scaled(const double x); ++ ++ ++/* Scaled irregular modified Bessel function ++ * exp(x) K_1(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_K1_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_K1_scaled(const double x); ++ ++ ++/* Scaled irregular modified Bessel function ++ * exp(x) K_n(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Kn_scaled_e(int n, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Kn_scaled(const int n, const double x); ++ ++ ++/* Scaled irregular modified Bessel function exp(x) K_n(x) for n=nmin,...,nmax ++ * ++ * x > 0.0, nmin >=0, nmax >= nmin ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Kn_scaled_array(const int nmin, const int nmax, const double x, double * result_array); ++ ++ ++/* Regular spherical Bessel function j_0(x) = sin(x)/x ++ * ++ * exceptions: none ++ */ ++int gsl_sf_bessel_j0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_j0(const double x); ++ ++ ++/* Regular spherical Bessel function j_1(x) = (sin(x)/x - cos(x))/x ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_j1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_j1(const double x); ++ ++ ++/* Regular spherical Bessel function j_2(x) = ((3/x^2 - 1)sin(x) - 3cos(x)/x)/x ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_j2_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_j2(const double x); ++ ++ ++/* Regular spherical Bessel function j_l(x) ++ * ++ * l >= 0, x >= 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_jl_e(const int l, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_jl(const int l, const double x); ++ ++ ++/* Regular spherical Bessel function j_l(x) for l=0,1,...,lmax ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_jl_array(const int lmax, const double x, double * result_array); ++ ++ ++/* Regular spherical Bessel function j_l(x) for l=0,1,...,lmax ++ * Uses Steed's method. ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_jl_steed_array(const int lmax, const double x, double * jl_x_array); ++ ++ ++/* Irregular spherical Bessel function y_0(x) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_bessel_y0_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_y0(const double x); ++ ++ ++/* Irregular spherical Bessel function y_1(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_y1_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_y1(const double x); ++ ++ ++/* Irregular spherical Bessel function y_2(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_y2_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_y2(const double x); ++ ++ ++/* Irregular spherical Bessel function y_l(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_yl_e(int l, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_yl(const int l, const double x); ++ ++ ++/* Irregular spherical Bessel function y_l(x) for l=0,1,...,lmax ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_yl_array(const int lmax, const double x, double * result_array); ++ ++ ++/* Regular scaled modified spherical Bessel function ++ * ++ * Exp[-|x|] i_0(x) ++ * ++ * exceptions: none ++ */ ++int gsl_sf_bessel_i0_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_i0_scaled(const double x); ++ ++ ++/* Regular scaled modified spherical Bessel function ++ * ++ * Exp[-|x|] i_1(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_i1_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_i1_scaled(const double x); ++ ++ ++/* Regular scaled modified spherical Bessel function ++ * ++ * Exp[-|x|] i_2(x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_i2_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_i2_scaled(const double x); ++ ++ ++/* Regular scaled modified spherical Bessel functions ++ * ++ * Exp[-|x|] i_l(x) ++ * ++ * i_l(x) = Sqrt[Pi/(2x)] BesselI[l+1/2,x] ++ * ++ * l >= 0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_il_scaled_e(const int l, double x, gsl_sf_result * result); ++double gsl_sf_bessel_il_scaled(const int l, const double x); ++ ++ ++/* Regular scaled modified spherical Bessel functions ++ * ++ * Exp[-|x|] i_l(x) ++ * for l=0,1,...,lmax ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_il_scaled_array(const int lmax, const double x, double * result_array); ++ ++ ++/* Irregular scaled modified spherical Bessel function ++ * Exp[x] k_0(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_k0_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_k0_scaled(const double x); ++ ++ ++/* Irregular modified spherical Bessel function ++ * Exp[x] k_1(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_bessel_k1_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_k1_scaled(const double x); ++ ++ ++/* Irregular modified spherical Bessel function ++ * Exp[x] k_2(x) ++ * ++ * x > 0.0 ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_bessel_k2_scaled_e(const double x, gsl_sf_result * result); ++double gsl_sf_bessel_k2_scaled(const double x); ++ ++ ++/* Irregular modified spherical Bessel function ++ * Exp[x] k_l[x] ++ * ++ * k_l(x) = Sqrt[Pi/(2x)] BesselK[l+1/2,x] ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_kl_scaled_e(int l, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_kl_scaled(const int l, const double x); ++ ++ ++/* Irregular scaled modified spherical Bessel function ++ * Exp[x] k_l(x) ++ * ++ * for l=0,1,...,lmax ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_kl_scaled_array(const int lmax, const double x, double * result_array); ++ ++ ++/* Regular cylindrical Bessel function J_nu(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Jnu_e(const double nu, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Jnu(const double nu, const double x); ++ ++ ++/* Irregular cylindrical Bessel function Y_nu(x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_bessel_Ynu_e(double nu, double x, gsl_sf_result * result); ++double gsl_sf_bessel_Ynu(const double nu, const double x); ++ ++ ++/* Regular cylindrical Bessel function J_nu(x) ++ * evaluated at a series of x values. The array ++ * contains the x values. They are assumed to be ++ * strictly ordered and positive. The array is ++ * over-written with the values of J_nu(x_i). ++ * ++ * exceptions: GSL_EDOM, GSL_EINVAL ++ */ ++int gsl_sf_bessel_sequence_Jnu_e(double nu, gsl_mode_t mode, size_t size, double * v); ++ ++ ++/* Scaled modified cylindrical Bessel functions ++ * ++ * Exp[-|x|] BesselI[nu, x] ++ * x >= 0, nu >= 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_bessel_Inu_scaled_e(double nu, double x, gsl_sf_result * result); ++double gsl_sf_bessel_Inu_scaled(double nu, double x); ++ ++ ++/* Modified cylindrical Bessel functions ++ * ++ * BesselI[nu, x] ++ * x >= 0, nu >= 0 ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_bessel_Inu_e(double nu, double x, gsl_sf_result * result); ++double gsl_sf_bessel_Inu(double nu, double x); ++ ++ ++/* Scaled modified cylindrical Bessel functions ++ * ++ * Exp[+|x|] BesselK[nu, x] ++ * x > 0, nu >= 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_bessel_Knu_scaled_e(const double nu, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Knu_scaled(const double nu, const double x); ++ ++int gsl_sf_bessel_Knu_scaled_e10_e(const double nu, const double x, gsl_sf_result_e10 * result); ++ ++/* Modified cylindrical Bessel functions ++ * ++ * BesselK[nu, x] ++ * x > 0, nu >= 0 ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_bessel_Knu_e(const double nu, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_Knu(const double nu, const double x); ++ ++ ++/* Logarithm of modified cylindrical Bessel functions. ++ * ++ * Log[BesselK[nu, x]] ++ * x > 0, nu >= 0 ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_bessel_lnKnu_e(const double nu, const double x, gsl_sf_result * result); ++double gsl_sf_bessel_lnKnu(const double nu, const double x); ++ ++ ++/* s'th positive zero of the Bessel function J_0(x). ++ * ++ * exceptions: ++ */ ++int gsl_sf_bessel_zero_J0_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_bessel_zero_J0(unsigned int s); ++ ++ ++/* s'th positive zero of the Bessel function J_1(x). ++ * ++ * exceptions: ++ */ ++int gsl_sf_bessel_zero_J1_e(unsigned int s, gsl_sf_result * result); ++double gsl_sf_bessel_zero_J1(unsigned int s); ++ ++ ++/* s'th positive zero of the Bessel function J_nu(x). ++ * ++ * exceptions: ++ */ ++int gsl_sf_bessel_zero_Jnu_e(double nu, unsigned int s, gsl_sf_result * result); ++double gsl_sf_bessel_zero_Jnu(double nu, unsigned int s); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_BESSEL_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h (revision 14078) +@@ -0,0 +1,93 @@ ++/* multiset/gsl_multiset.h ++ * based on combination/gsl_combination.h by Szymon Jaroszewicz ++ * based on permutation/gsl_permutation.h by Brian Gough ++ * ++ * Copyright (C) 2009 Rhys Ulerich ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MULTISET_H__ ++#define __GSL_MULTISET_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_multiset_struct ++{ ++ size_t n; ++ size_t k; ++ size_t *data; ++}; ++ ++typedef struct gsl_multiset_struct gsl_multiset; ++ ++gsl_multiset *gsl_multiset_alloc (const size_t n, const size_t k); ++gsl_multiset *gsl_multiset_calloc (const size_t n, const size_t k); ++void gsl_multiset_init_first (gsl_multiset * c); ++void gsl_multiset_init_last (gsl_multiset * c); ++void gsl_multiset_free (gsl_multiset * c); ++int gsl_multiset_memcpy (gsl_multiset * dest, const gsl_multiset * src); ++ ++int gsl_multiset_fread (FILE * stream, gsl_multiset * c); ++int gsl_multiset_fwrite (FILE * stream, const gsl_multiset * c); ++int gsl_multiset_fscanf (FILE * stream, gsl_multiset * c); ++int gsl_multiset_fprintf (FILE * stream, const gsl_multiset * c, const char *format); ++ ++size_t gsl_multiset_n (const gsl_multiset * c); ++size_t gsl_multiset_k (const gsl_multiset * c); ++size_t * gsl_multiset_data (const gsl_multiset * c); ++ ++int gsl_multiset_valid (gsl_multiset * c); ++int gsl_multiset_next (gsl_multiset * c); ++int gsl_multiset_prev (gsl_multiset * c); ++ ++INLINE_DECL size_t gsl_multiset_get (const gsl_multiset * c, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++size_t ++gsl_multiset_get (const gsl_multiset * c, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= c->k)) /* size_t is unsigned, can't be negative */ ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return c->data[i]; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_MULTISET_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h (revision 14078) +@@ -0,0 +1,10 @@ ++/* Author: G. Jungman */ ++ ++ ++/* Convenience header */ ++#ifndef __GSL_SPECFUNC_H__ ++#define __GSL_SPECFUNC_H__ ++ ++#include ++ ++#endif /* __GSL_SPECFUNC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_UCHAR_H__ ++#define __GSL_BLOCK_UCHAR_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_uchar_struct ++{ ++ size_t size; ++ unsigned char *data; ++}; ++ ++typedef struct gsl_block_uchar_struct gsl_block_uchar; ++ ++gsl_block_uchar *gsl_block_uchar_alloc (const size_t n); ++gsl_block_uchar *gsl_block_uchar_calloc (const size_t n); ++void gsl_block_uchar_free (gsl_block_uchar * b); ++ ++int gsl_block_uchar_fread (FILE * stream, gsl_block_uchar * b); ++int gsl_block_uchar_fwrite (FILE * stream, const gsl_block_uchar * b); ++int gsl_block_uchar_fscanf (FILE * stream, gsl_block_uchar * b); ++int gsl_block_uchar_fprintf (FILE * stream, const gsl_block_uchar * b, const char *format); ++ ++int gsl_block_uchar_raw_fread (FILE * stream, unsigned char * b, const size_t n, const size_t stride); ++int gsl_block_uchar_raw_fwrite (FILE * stream, const unsigned char * b, const size_t n, const size_t stride); ++int gsl_block_uchar_raw_fscanf (FILE * stream, unsigned char * b, const size_t n, const size_t stride); ++int gsl_block_uchar_raw_fprintf (FILE * stream, const unsigned char * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_uchar_size (const gsl_block_uchar * b); ++unsigned char * gsl_block_uchar_data (const gsl_block_uchar * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_FLOAT_H__ ++#define __GSL_SORT_FLOAT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_float (float * data, const size_t stride, const size_t n); ++void gsl_sort_float_index (size_t * p, const float * data, const size_t stride, const size_t n); ++ ++int gsl_sort_float_smallest (float * dest, const size_t k, const float * src, const size_t stride, const size_t n); ++int gsl_sort_float_smallest_index (size_t * p, const size_t k, const float * src, const size_t stride, const size_t n); ++ ++int gsl_sort_float_largest (float * dest, const size_t k, const float * src, const size_t stride, const size_t n); ++int gsl_sort_float_largest_index (size_t * p, const size_t k, const float * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h (revision 14078) +@@ -0,0 +1,142 @@ ++/* complex/gsl_complex_math.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Jorma Olavi Tähtinen, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_COMPLEX_MATH_H__ ++#define __GSL_COMPLEX_MATH_H__ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++#define __BEGIN_DECLS extern "C" { ++#define __END_DECLS } ++#else ++#define __BEGIN_DECLS /* empty */ ++#define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Complex numbers */ ++ ++gsl_complex gsl_complex_polar (double r, double theta); /* r= r e^(i theta) */ ++ ++INLINE_DECL gsl_complex gsl_complex_rect (double x, double y); /* r= real+i*imag */ ++ ++#ifdef HAVE_INLINE ++INLINE_FUN gsl_complex ++gsl_complex_rect (double x, double y) ++{ /* return z = x + i y */ ++ gsl_complex z; ++ GSL_SET_COMPLEX (&z, x, y); ++ return z; ++} ++#endif ++ ++#define GSL_COMPLEX_ONE (gsl_complex_rect(1.0,0.0)) ++#define GSL_COMPLEX_ZERO (gsl_complex_rect(0.0,0.0)) ++#define GSL_COMPLEX_NEGONE (gsl_complex_rect(-1.0,0.0)) ++ ++/* Properties of complex numbers */ ++ ++double gsl_complex_arg (gsl_complex z); /* return arg(z), -pi< arg(z) <=+pi */ ++double gsl_complex_abs (gsl_complex z); /* return |z| */ ++double gsl_complex_abs2 (gsl_complex z); /* return |z|^2 */ ++double gsl_complex_logabs (gsl_complex z); /* return log|z| */ ++ ++/* Complex arithmetic operators */ ++ ++gsl_complex gsl_complex_add (gsl_complex a, gsl_complex b); /* r=a+b */ ++gsl_complex gsl_complex_sub (gsl_complex a, gsl_complex b); /* r=a-b */ ++gsl_complex gsl_complex_mul (gsl_complex a, gsl_complex b); /* r=a*b */ ++gsl_complex gsl_complex_div (gsl_complex a, gsl_complex b); /* r=a/b */ ++ ++gsl_complex gsl_complex_add_real (gsl_complex a, double x); /* r=a+x */ ++gsl_complex gsl_complex_sub_real (gsl_complex a, double x); /* r=a-x */ ++gsl_complex gsl_complex_mul_real (gsl_complex a, double x); /* r=a*x */ ++gsl_complex gsl_complex_div_real (gsl_complex a, double x); /* r=a/x */ ++ ++gsl_complex gsl_complex_add_imag (gsl_complex a, double y); /* r=a+iy */ ++gsl_complex gsl_complex_sub_imag (gsl_complex a, double y); /* r=a-iy */ ++gsl_complex gsl_complex_mul_imag (gsl_complex a, double y); /* r=a*iy */ ++gsl_complex gsl_complex_div_imag (gsl_complex a, double y); /* r=a/iy */ ++ ++gsl_complex gsl_complex_conjugate (gsl_complex z); /* r=conj(z) */ ++gsl_complex gsl_complex_inverse (gsl_complex a); /* r=1/a */ ++gsl_complex gsl_complex_negative (gsl_complex a); /* r=-a */ ++ ++/* Elementary Complex Functions */ ++ ++gsl_complex gsl_complex_sqrt (gsl_complex z); /* r=sqrt(z) */ ++gsl_complex gsl_complex_sqrt_real (double x); /* r=sqrt(x) (x<0 ok) */ ++ ++gsl_complex gsl_complex_pow (gsl_complex a, gsl_complex b); /* r=a^b */ ++gsl_complex gsl_complex_pow_real (gsl_complex a, double b); /* r=a^b */ ++ ++gsl_complex gsl_complex_exp (gsl_complex a); /* r=exp(a) */ ++gsl_complex gsl_complex_log (gsl_complex a); /* r=log(a) (base e) */ ++gsl_complex gsl_complex_log10 (gsl_complex a); /* r=log10(a) (base 10) */ ++gsl_complex gsl_complex_log_b (gsl_complex a, gsl_complex b); /* r=log_b(a) (base=b) */ ++ ++/* Complex Trigonometric Functions */ ++ ++gsl_complex gsl_complex_sin (gsl_complex a); /* r=sin(a) */ ++gsl_complex gsl_complex_cos (gsl_complex a); /* r=cos(a) */ ++gsl_complex gsl_complex_sec (gsl_complex a); /* r=sec(a) */ ++gsl_complex gsl_complex_csc (gsl_complex a); /* r=csc(a) */ ++gsl_complex gsl_complex_tan (gsl_complex a); /* r=tan(a) */ ++gsl_complex gsl_complex_cot (gsl_complex a); /* r=cot(a) */ ++ ++/* Inverse Complex Trigonometric Functions */ ++ ++gsl_complex gsl_complex_arcsin (gsl_complex a); /* r=arcsin(a) */ ++gsl_complex gsl_complex_arcsin_real (double a); /* r=arcsin(a) */ ++gsl_complex gsl_complex_arccos (gsl_complex a); /* r=arccos(a) */ ++gsl_complex gsl_complex_arccos_real (double a); /* r=arccos(a) */ ++gsl_complex gsl_complex_arcsec (gsl_complex a); /* r=arcsec(a) */ ++gsl_complex gsl_complex_arcsec_real (double a); /* r=arcsec(a) */ ++gsl_complex gsl_complex_arccsc (gsl_complex a); /* r=arccsc(a) */ ++gsl_complex gsl_complex_arccsc_real (double a); /* r=arccsc(a) */ ++gsl_complex gsl_complex_arctan (gsl_complex a); /* r=arctan(a) */ ++gsl_complex gsl_complex_arccot (gsl_complex a); /* r=arccot(a) */ ++ ++/* Complex Hyperbolic Functions */ ++ ++gsl_complex gsl_complex_sinh (gsl_complex a); /* r=sinh(a) */ ++gsl_complex gsl_complex_cosh (gsl_complex a); /* r=coshh(a) */ ++gsl_complex gsl_complex_sech (gsl_complex a); /* r=sech(a) */ ++gsl_complex gsl_complex_csch (gsl_complex a); /* r=csch(a) */ ++gsl_complex gsl_complex_tanh (gsl_complex a); /* r=tanh(a) */ ++gsl_complex gsl_complex_coth (gsl_complex a); /* r=coth(a) */ ++ ++/* Inverse Complex Hyperbolic Functions */ ++ ++gsl_complex gsl_complex_arcsinh (gsl_complex a); /* r=arcsinh(a) */ ++gsl_complex gsl_complex_arccosh (gsl_complex a); /* r=arccosh(a) */ ++gsl_complex gsl_complex_arccosh_real (double a); /* r=arccosh(a) */ ++gsl_complex gsl_complex_arcsech (gsl_complex a); /* r=arcsech(a) */ ++gsl_complex gsl_complex_arccsch (gsl_complex a); /* r=arccsch(a) */ ++gsl_complex gsl_complex_arctanh (gsl_complex a); /* r=arctanh(a) */ ++gsl_complex gsl_complex_arctanh_real (double a); /* r=arctanh(a) */ ++gsl_complex gsl_complex_arccoth (gsl_complex a); /* r=arccoth(a) */ ++ ++__END_DECLS ++ ++#endif /* __GSL_COMPLEX_MATH_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h (revision 14078) +@@ -0,0 +1,60 @@ ++/* specfunc/gsl_sf_synchrotron.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_SYNCHROTRON_H__ ++#define __GSL_SF_SYNCHROTRON_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* First synchrotron function: ++ * synchrotron_1(x) = x Integral[ K_{5/3}(t), {t, x, Infinity}] ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_synchrotron_1_e(const double x, gsl_sf_result * result); ++double gsl_sf_synchrotron_1(const double x); ++ ++ ++/* Second synchroton function: ++ * synchrotron_2(x) = x * K_{2/3}(x) ++ * ++ * exceptions: GSL_EDOM, GSL_EUNDRFLW ++ */ ++int gsl_sf_synchrotron_2_e(const double x, gsl_sf_result * result); ++double gsl_sf_synchrotron_2(const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_SYNCHROTRON_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h (revision 14078) +@@ -0,0 +1,24 @@ ++#ifndef __GSL_PERMUTE_H__ ++#define __GSL_PERMUTE_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_PERMUTE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_LONG_H__ ++#define __GSL_VECTOR_LONG_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ long *data; ++ gsl_block_long *block; ++ int owner; ++} ++gsl_vector_long; ++ ++typedef struct ++{ ++ gsl_vector_long vector; ++} _gsl_vector_long_view; ++ ++typedef _gsl_vector_long_view gsl_vector_long_view; ++ ++typedef struct ++{ ++ gsl_vector_long vector; ++} _gsl_vector_long_const_view; ++ ++typedef const _gsl_vector_long_const_view gsl_vector_long_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_long *gsl_vector_long_alloc (const size_t n); ++gsl_vector_long *gsl_vector_long_calloc (const size_t n); ++ ++gsl_vector_long *gsl_vector_long_alloc_from_block (gsl_block_long * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_long *gsl_vector_long_alloc_from_vector (gsl_vector_long * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_long_free (gsl_vector_long * v); ++ ++/* Views */ ++ ++_gsl_vector_long_view ++gsl_vector_long_view_array (long *v, size_t n); ++ ++_gsl_vector_long_view ++gsl_vector_long_view_array_with_stride (long *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_const_view ++gsl_vector_long_const_view_array (const long *v, size_t n); ++ ++_gsl_vector_long_const_view ++gsl_vector_long_const_view_array_with_stride (const long *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_view ++gsl_vector_long_subvector (gsl_vector_long *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_long_view ++gsl_vector_long_subvector_with_stride (gsl_vector_long *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_const_view ++gsl_vector_long_const_subvector (const gsl_vector_long *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_long_const_view ++gsl_vector_long_const_subvector_with_stride (const gsl_vector_long *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_long_set_zero (gsl_vector_long * v); ++void gsl_vector_long_set_all (gsl_vector_long * v, long x); ++int gsl_vector_long_set_basis (gsl_vector_long * v, size_t i); ++ ++int gsl_vector_long_fread (FILE * stream, gsl_vector_long * v); ++int gsl_vector_long_fwrite (FILE * stream, const gsl_vector_long * v); ++int gsl_vector_long_fscanf (FILE * stream, gsl_vector_long * v); ++int gsl_vector_long_fprintf (FILE * stream, const gsl_vector_long * v, ++ const char *format); ++ ++int gsl_vector_long_memcpy (gsl_vector_long * dest, const gsl_vector_long * src); ++ ++int gsl_vector_long_reverse (gsl_vector_long * v); ++ ++int gsl_vector_long_swap (gsl_vector_long * v, gsl_vector_long * w); ++int gsl_vector_long_swap_elements (gsl_vector_long * v, const size_t i, const size_t j); ++ ++long gsl_vector_long_max (const gsl_vector_long * v); ++long gsl_vector_long_min (const gsl_vector_long * v); ++void gsl_vector_long_minmax (const gsl_vector_long * v, long * min_out, long * max_out); ++ ++size_t gsl_vector_long_max_index (const gsl_vector_long * v); ++size_t gsl_vector_long_min_index (const gsl_vector_long * v); ++void gsl_vector_long_minmax_index (const gsl_vector_long * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_long_add (gsl_vector_long * a, const gsl_vector_long * b); ++int gsl_vector_long_sub (gsl_vector_long * a, const gsl_vector_long * b); ++int gsl_vector_long_mul (gsl_vector_long * a, const gsl_vector_long * b); ++int gsl_vector_long_div (gsl_vector_long * a, const gsl_vector_long * b); ++int gsl_vector_long_scale (gsl_vector_long * a, const double x); ++int gsl_vector_long_add_constant (gsl_vector_long * a, const double x); ++ ++int gsl_vector_long_equal (const gsl_vector_long * u, ++ const gsl_vector_long * v); ++ ++int gsl_vector_long_isnull (const gsl_vector_long * v); ++int gsl_vector_long_ispos (const gsl_vector_long * v); ++int gsl_vector_long_isneg (const gsl_vector_long * v); ++int gsl_vector_long_isnonneg (const gsl_vector_long * v); ++ ++INLINE_DECL long gsl_vector_long_get (const gsl_vector_long * v, const size_t i); ++INLINE_DECL void gsl_vector_long_set (gsl_vector_long * v, const size_t i, long x); ++INLINE_DECL long * gsl_vector_long_ptr (gsl_vector_long * v, const size_t i); ++INLINE_DECL const long * gsl_vector_long_const_ptr (const gsl_vector_long * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++long ++gsl_vector_long_get (const gsl_vector_long * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_long_set (gsl_vector_long * v, const size_t i, long x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++long * ++gsl_vector_long_ptr (gsl_vector_long * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (long *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const long * ++gsl_vector_long_const_ptr (const gsl_vector_long * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const long *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_LONG_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_SHORT_H__ ++#define __GSL_PERMUTE_VECTOR_SHORT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_short (const gsl_permutation * p, gsl_vector_short * v); ++int gsl_permute_vector_short_inverse (const gsl_permutation * p, gsl_vector_short * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_LONG_H__ ++#define __GSL_PERMUTE_VECTOR_LONG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_long (const gsl_permutation * p, gsl_vector_long * v); ++int gsl_permute_vector_long_inverse (const gsl_permutation * p, gsl_vector_long * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h (revision 14078) +@@ -0,0 +1,44 @@ ++/* permutation/gsl_permute_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_USHORT_H__ ++#define __GSL_PERMUTE_USHORT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_ushort (const size_t * p, unsigned short * data, const size_t stride, const size_t n); ++int gsl_permute_ushort_inverse (const size_t * p, unsigned short * data, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h (revision 14078) +@@ -0,0 +1,351 @@ ++/* matrix/gsl_matrix_complex_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_COMPLEX_DOUBLE_H__ ++#define __GSL_MATRIX_COMPLEX_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ double * data; ++ gsl_block_complex * block; ++ int owner; ++} gsl_matrix_complex ; ++ ++typedef struct ++{ ++ gsl_matrix_complex matrix; ++} _gsl_matrix_complex_view; ++ ++typedef _gsl_matrix_complex_view gsl_matrix_complex_view; ++ ++typedef struct ++{ ++ gsl_matrix_complex matrix; ++} _gsl_matrix_complex_const_view; ++ ++typedef const _gsl_matrix_complex_const_view gsl_matrix_complex_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_matrix_complex * ++gsl_matrix_complex_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex * ++gsl_matrix_complex_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex * ++gsl_matrix_complex_alloc_from_block (gsl_block_complex * b, ++ const size_t offset, ++ const size_t n1, const size_t n2, const size_t d2); ++ ++gsl_matrix_complex * ++gsl_matrix_complex_alloc_from_matrix (gsl_matrix_complex * b, ++ const size_t k1, const size_t k2, ++ const size_t n1, const size_t n2); ++ ++gsl_vector_complex * ++gsl_vector_complex_alloc_row_from_matrix (gsl_matrix_complex * m, ++ const size_t i); ++ ++gsl_vector_complex * ++gsl_vector_complex_alloc_col_from_matrix (gsl_matrix_complex * m, ++ const size_t j); ++ ++void gsl_matrix_complex_free (gsl_matrix_complex * m); ++ ++/* Views */ ++ ++_gsl_matrix_complex_view ++gsl_matrix_complex_submatrix (gsl_matrix_complex * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_row (gsl_matrix_complex * m, const size_t i); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_column (gsl_matrix_complex * m, const size_t j); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_diagonal (gsl_matrix_complex * m); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_subdiagonal (gsl_matrix_complex * m, const size_t k); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_superdiagonal (gsl_matrix_complex * m, const size_t k); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_subrow (gsl_matrix_complex * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_view ++gsl_matrix_complex_subcolumn (gsl_matrix_complex * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_view ++gsl_matrix_complex_view_array (double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_view ++gsl_matrix_complex_view_array_with_tda (double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_view ++gsl_matrix_complex_view_vector (gsl_vector_complex * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_view ++gsl_matrix_complex_view_vector_with_tda (gsl_vector_complex * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_complex_const_view ++gsl_matrix_complex_const_submatrix (const gsl_matrix_complex * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_row (const gsl_matrix_complex * m, ++ const size_t i); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_column (const gsl_matrix_complex * m, ++ const size_t j); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_diagonal (const gsl_matrix_complex * m); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_subdiagonal (const gsl_matrix_complex * m, ++ const size_t k); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_superdiagonal (const gsl_matrix_complex * m, ++ const size_t k); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_subrow (const gsl_matrix_complex * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_const_view ++gsl_matrix_complex_const_subcolumn (const gsl_matrix_complex * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_const_view ++gsl_matrix_complex_const_view_array (const double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_const_view ++gsl_matrix_complex_const_view_array_with_tda (const double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_const_view ++gsl_matrix_complex_const_view_vector (const gsl_vector_complex * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_const_view ++gsl_matrix_complex_const_view_vector_with_tda (const gsl_vector_complex * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_complex_set_zero (gsl_matrix_complex * m); ++void gsl_matrix_complex_set_identity (gsl_matrix_complex * m); ++void gsl_matrix_complex_set_all (gsl_matrix_complex * m, gsl_complex x); ++ ++int gsl_matrix_complex_fread (FILE * stream, gsl_matrix_complex * m) ; ++int gsl_matrix_complex_fwrite (FILE * stream, const gsl_matrix_complex * m) ; ++int gsl_matrix_complex_fscanf (FILE * stream, gsl_matrix_complex * m); ++int gsl_matrix_complex_fprintf (FILE * stream, const gsl_matrix_complex * m, const char * format); ++ ++int gsl_matrix_complex_memcpy(gsl_matrix_complex * dest, const gsl_matrix_complex * src); ++int gsl_matrix_complex_swap(gsl_matrix_complex * m1, gsl_matrix_complex * m2); ++ ++int gsl_matrix_complex_swap_rows(gsl_matrix_complex * m, const size_t i, const size_t j); ++int gsl_matrix_complex_swap_columns(gsl_matrix_complex * m, const size_t i, const size_t j); ++int gsl_matrix_complex_swap_rowcol(gsl_matrix_complex * m, const size_t i, const size_t j); ++ ++int gsl_matrix_complex_transpose (gsl_matrix_complex * m); ++int gsl_matrix_complex_transpose_memcpy (gsl_matrix_complex * dest, const gsl_matrix_complex * src); ++ ++int gsl_matrix_complex_equal (const gsl_matrix_complex * a, const gsl_matrix_complex * b); ++ ++int gsl_matrix_complex_isnull (const gsl_matrix_complex * m); ++int gsl_matrix_complex_ispos (const gsl_matrix_complex * m); ++int gsl_matrix_complex_isneg (const gsl_matrix_complex * m); ++int gsl_matrix_complex_isnonneg (const gsl_matrix_complex * m); ++ ++int gsl_matrix_complex_add (gsl_matrix_complex * a, const gsl_matrix_complex * b); ++int gsl_matrix_complex_sub (gsl_matrix_complex * a, const gsl_matrix_complex * b); ++int gsl_matrix_complex_mul_elements (gsl_matrix_complex * a, const gsl_matrix_complex * b); ++int gsl_matrix_complex_div_elements (gsl_matrix_complex * a, const gsl_matrix_complex * b); ++int gsl_matrix_complex_scale (gsl_matrix_complex * a, const gsl_complex x); ++int gsl_matrix_complex_add_constant (gsl_matrix_complex * a, const gsl_complex x); ++int gsl_matrix_complex_add_diagonal (gsl_matrix_complex * a, const gsl_complex x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_complex_get_row(gsl_vector_complex * v, const gsl_matrix_complex * m, const size_t i); ++int gsl_matrix_complex_get_col(gsl_vector_complex * v, const gsl_matrix_complex * m, const size_t j); ++int gsl_matrix_complex_set_row(gsl_matrix_complex * m, const size_t i, const gsl_vector_complex * v); ++int gsl_matrix_complex_set_col(gsl_matrix_complex * m, const size_t j, const gsl_vector_complex * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL gsl_complex gsl_matrix_complex_get(const gsl_matrix_complex * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_complex_set(gsl_matrix_complex * m, const size_t i, const size_t j, const gsl_complex x); ++ ++INLINE_DECL gsl_complex * gsl_matrix_complex_ptr(gsl_matrix_complex * m, const size_t i, const size_t j); ++INLINE_DECL const gsl_complex * gsl_matrix_complex_const_ptr(const gsl_matrix_complex * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex ++gsl_matrix_complex_get(const gsl_matrix_complex * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ gsl_complex zero = {{0,0}}; ++ ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; ++ } ++ } ++#endif ++ return *(gsl_complex *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_complex_set(gsl_matrix_complex * m, ++ const size_t i, const size_t j, const gsl_complex x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ *(gsl_complex *)(m->data + 2*(i * m->tda + j)) = x ; ++} ++ ++INLINE_FUN ++gsl_complex * ++gsl_matrix_complex_ptr(gsl_matrix_complex * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (gsl_complex *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const gsl_complex * ++gsl_matrix_complex_const_ptr(const gsl_matrix_complex * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const gsl_complex *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h (revision 14078) +@@ -0,0 +1,154 @@ ++/* specfunc/gsl_sf_hyperg.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_HYPERG_H__ ++#define __GSL_SF_HYPERG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Hypergeometric function related to Bessel functions ++ * 0F1[c,x] = ++ * Gamma[c] x^(1/2(1-c)) I_{c-1}(2 Sqrt[x]) ++ * Gamma[c] (-x)^(1/2(1-c)) J_{c-1}(2 Sqrt[-x]) ++ * ++ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW ++ */ ++int gsl_sf_hyperg_0F1_e(double c, double x, gsl_sf_result * result); ++double gsl_sf_hyperg_0F1(const double c, const double x); ++ ++ ++/* Confluent hypergeometric function for integer parameters. ++ * 1F1[m,n,x] = M(m,n,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_1F1_int_e(const int m, const int n, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_1F1_int(const int m, const int n, double x); ++ ++ ++/* Confluent hypergeometric function. ++ * 1F1[a,b,x] = M(a,b,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_1F1_e(const double a, const double b, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_1F1(double a, double b, double x); ++ ++ ++/* Confluent hypergeometric function for integer parameters. ++ * U(m,n,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_U_int_e(const int m, const int n, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_U_int(const int m, const int n, const double x); ++ ++ ++/* Confluent hypergeometric function for integer parameters. ++ * U(m,n,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_U_int_e10_e(const int m, const int n, const double x, gsl_sf_result_e10 * result); ++ ++ ++/* Confluent hypergeometric function. ++ * U(a,b,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_U_e(const double a, const double b, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_U(const double a, const double b, const double x); ++ ++ ++/* Confluent hypergeometric function. ++ * U(a,b,x) ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_U_e10_e(const double a, const double b, const double x, gsl_sf_result_e10 * result); ++ ++ ++/* Gauss hypergeometric function 2F1[a,b,c,x] ++ * |x| < 1 ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_2F1_e(double a, double b, const double c, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_2F1(double a, double b, double c, double x); ++ ++ ++/* Gauss hypergeometric function ++ * 2F1[aR + I aI, aR - I aI, c, x] ++ * |x| < 1 ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_2F1_conj_e(const double aR, const double aI, const double c, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_2F1_conj(double aR, double aI, double c, double x); ++ ++ ++/* Renormalized Gauss hypergeometric function ++ * 2F1[a,b,c,x] / Gamma[c] ++ * |x| < 1 ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_2F1_renorm_e(const double a, const double b, const double c, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_2F1_renorm(double a, double b, double c, double x); ++ ++ ++/* Renormalized Gauss hypergeometric function ++ * 2F1[aR + I aI, aR - I aI, c, x] / Gamma[c] ++ * |x| < 1 ++ * ++ * exceptions: ++ */ ++int gsl_sf_hyperg_2F1_conj_renorm_e(const double aR, const double aI, const double c, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_2F1_conj_renorm(double aR, double aI, double c, double x); ++ ++ ++/* Mysterious hypergeometric function. The series representation ++ * is a divergent hypergeometric series. However, for x < 0 we ++ * have 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x) ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_hyperg_2F0_e(const double a, const double b, const double x, gsl_sf_result * result); ++double gsl_sf_hyperg_2F0(const double a, const double b, const double x); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_HYPERG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_USHORT_H__ ++#define __GSL_SORT_USHORT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_ushort (unsigned short * data, const size_t stride, const size_t n); ++void gsl_sort_ushort_index (size_t * p, const unsigned short * data, const size_t stride, const size_t n); ++ ++int gsl_sort_ushort_smallest (unsigned short * dest, const size_t k, const unsigned short * src, const size_t stride, const size_t n); ++int gsl_sort_ushort_smallest_index (size_t * p, const size_t k, const unsigned short * src, const size_t stride, const size_t n); ++ ++int gsl_sort_ushort_largest (unsigned short * dest, const size_t k, const unsigned short * src, const size_t stride, const size_t n); ++int gsl_sort_ushort_largest_index (size_t * p, const size_t k, const unsigned short * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_USHORT_H__ ++#define __GSL_STATISTICS_USHORT_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_ushort_mean (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_variance (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_sd (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_variance_with_fixed_mean (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ushort_sd_with_fixed_mean (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ushort_tss (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_tss_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_ushort_absdev (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_skew (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_kurtosis (const unsigned short data[], const size_t stride, const size_t n); ++double gsl_stats_ushort_lag1_autocorrelation (const unsigned short data[], const size_t stride, const size_t n); ++ ++double gsl_stats_ushort_covariance (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n); ++double gsl_stats_ushort_correlation (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_ushort_variance_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ushort_sd_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ushort_absdev_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_ushort_skew_m_sd (const unsigned short data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_ushort_kurtosis_m_sd (const unsigned short data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_ushort_lag1_autocorrelation_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_ushort_covariance_m (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_ushort_pvariance (const unsigned short data1[], const size_t stride1, const size_t n1, const unsigned short data2[], const size_t stride2, const size_t n2); ++double gsl_stats_ushort_ttest (const unsigned short data1[], const size_t stride1, const size_t n1, const unsigned short data2[], const size_t stride2, const size_t n2); ++ ++unsigned short gsl_stats_ushort_max (const unsigned short data[], const size_t stride, const size_t n); ++unsigned short gsl_stats_ushort_min (const unsigned short data[], const size_t stride, const size_t n); ++void gsl_stats_ushort_minmax (unsigned short * min, unsigned short * max, const unsigned short data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_ushort_max_index (const unsigned short data[], const size_t stride, const size_t n); ++size_t gsl_stats_ushort_min_index (const unsigned short data[], const size_t stride, const size_t n); ++void gsl_stats_ushort_minmax_index (size_t * min_index, size_t * max_index, const unsigned short data[], const size_t stride, const size_t n); ++ ++double gsl_stats_ushort_median_from_sorted_data (const unsigned short sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_ushort_quantile_from_sorted_data (const unsigned short sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_INT_H__ ++#define __GSL_SORT_INT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_int (int * data, const size_t stride, const size_t n); ++void gsl_sort_int_index (size_t * p, const int * data, const size_t stride, const size_t n); ++ ++int gsl_sort_int_smallest (int * dest, const size_t k, const int * src, const size_t stride, const size_t n); ++int gsl_sort_int_smallest_index (size_t * p, const size_t k, const int * src, const size_t stride, const size_t n); ++ ++int gsl_sort_int_largest (int * dest, const size_t k, const int * src, const size_t stride, const size_t n); ++int gsl_sort_int_largest_index (size_t * p, const size_t k, const int * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h (revision 14078) +@@ -0,0 +1,251 @@ ++/* vector/gsl_vector_complex_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ ++#define __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ long double *data; ++ gsl_block_complex_long_double *block; ++ int owner; ++} gsl_vector_complex_long_double; ++ ++typedef struct ++{ ++ gsl_vector_complex_long_double vector; ++} _gsl_vector_complex_long_double_view; ++ ++typedef _gsl_vector_complex_long_double_view gsl_vector_complex_long_double_view; ++ ++typedef struct ++{ ++ gsl_vector_complex_long_double vector; ++} _gsl_vector_complex_long_double_const_view; ++ ++typedef const _gsl_vector_complex_long_double_const_view gsl_vector_complex_long_double_const_view; ++ ++/* Allocation */ ++ ++gsl_vector_complex_long_double *gsl_vector_complex_long_double_alloc (const size_t n); ++gsl_vector_complex_long_double *gsl_vector_complex_long_double_calloc (const size_t n); ++ ++gsl_vector_complex_long_double * ++gsl_vector_complex_long_double_alloc_from_block (gsl_block_complex_long_double * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_complex_long_double * ++gsl_vector_complex_long_double_alloc_from_vector (gsl_vector_complex_long_double * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_complex_long_double_free (gsl_vector_complex_long_double * v); ++ ++/* Views */ ++ ++_gsl_vector_complex_long_double_view ++gsl_vector_complex_long_double_view_array (long double *base, ++ size_t n); ++ ++_gsl_vector_complex_long_double_view ++gsl_vector_complex_long_double_view_array_with_stride (long double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_vector_complex_long_double_const_view_array (const long double *base, ++ size_t n); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_vector_complex_long_double_const_view_array_with_stride (const long double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_long_double_view ++gsl_vector_complex_long_double_subvector (gsl_vector_complex_long_double *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_long_double_view ++gsl_vector_complex_long_double_subvector_with_stride (gsl_vector_complex_long_double *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_vector_complex_long_double_const_subvector (const gsl_vector_complex_long_double *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_long_double_const_view ++gsl_vector_complex_long_double_const_subvector_with_stride (const gsl_vector_complex_long_double *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_long_double_view ++gsl_vector_complex_long_double_real (gsl_vector_complex_long_double *v); ++ ++_gsl_vector_long_double_view ++gsl_vector_complex_long_double_imag (gsl_vector_complex_long_double *v); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_complex_long_double_const_real (const gsl_vector_complex_long_double *v); ++ ++_gsl_vector_long_double_const_view ++gsl_vector_complex_long_double_const_imag (const gsl_vector_complex_long_double *v); ++ ++ ++/* Operations */ ++ ++void gsl_vector_complex_long_double_set_zero (gsl_vector_complex_long_double * v); ++void gsl_vector_complex_long_double_set_all (gsl_vector_complex_long_double * v, ++ gsl_complex_long_double z); ++int gsl_vector_complex_long_double_set_basis (gsl_vector_complex_long_double * v, size_t i); ++ ++int gsl_vector_complex_long_double_fread (FILE * stream, ++ gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_fwrite (FILE * stream, ++ const gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_fscanf (FILE * stream, ++ gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_fprintf (FILE * stream, ++ const gsl_vector_complex_long_double * v, ++ const char *format); ++ ++int gsl_vector_complex_long_double_memcpy (gsl_vector_complex_long_double * dest, const gsl_vector_complex_long_double * src); ++ ++int gsl_vector_complex_long_double_reverse (gsl_vector_complex_long_double * v); ++ ++int gsl_vector_complex_long_double_swap (gsl_vector_complex_long_double * v, gsl_vector_complex_long_double * w); ++int gsl_vector_complex_long_double_swap_elements (gsl_vector_complex_long_double * v, const size_t i, const size_t j); ++ ++int gsl_vector_complex_long_double_equal (const gsl_vector_complex_long_double * u, ++ const gsl_vector_complex_long_double * v); ++ ++int gsl_vector_complex_long_double_isnull (const gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_ispos (const gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_isneg (const gsl_vector_complex_long_double * v); ++int gsl_vector_complex_long_double_isnonneg (const gsl_vector_complex_long_double * v); ++ ++int gsl_vector_complex_long_double_add (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); ++int gsl_vector_complex_long_double_sub (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); ++int gsl_vector_complex_long_double_mul (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); ++int gsl_vector_complex_long_double_div (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); ++int gsl_vector_complex_long_double_scale (gsl_vector_complex_long_double * a, const gsl_complex_long_double x); ++int gsl_vector_complex_long_double_add_constant (gsl_vector_complex_long_double * a, const gsl_complex_long_double x); ++ ++INLINE_DECL gsl_complex_long_double gsl_vector_complex_long_double_get (const gsl_vector_complex_long_double * v, const size_t i); ++INLINE_DECL void gsl_vector_complex_long_double_set (gsl_vector_complex_long_double * v, const size_t i, gsl_complex_long_double z); ++INLINE_DECL gsl_complex_long_double *gsl_vector_complex_long_double_ptr (gsl_vector_complex_long_double * v, const size_t i); ++INLINE_DECL const gsl_complex_long_double *gsl_vector_complex_long_double_const_ptr (const gsl_vector_complex_long_double * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex_long_double ++gsl_vector_complex_long_double_get (const gsl_vector_complex_long_double * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ gsl_complex_long_double zero = {{0, 0}}; ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); ++ } ++#endif ++ return *GSL_COMPLEX_LONG_DOUBLE_AT (v, i); ++} ++ ++INLINE_FUN ++void ++gsl_vector_complex_long_double_set (gsl_vector_complex_long_double * v, ++ const size_t i, gsl_complex_long_double z) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ *GSL_COMPLEX_LONG_DOUBLE_AT (v, i) = z; ++} ++ ++INLINE_FUN ++gsl_complex_long_double * ++gsl_vector_complex_long_double_ptr (gsl_vector_complex_long_double * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_LONG_DOUBLE_AT (v, i); ++} ++ ++INLINE_FUN ++const gsl_complex_long_double * ++gsl_vector_complex_long_double_const_ptr (const gsl_vector_complex_long_double * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_LONG_DOUBLE_AT (v, i); ++} ++ ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h (revision 14078) +@@ -0,0 +1,24 @@ ++#ifndef __GSL_PERMUTE_VECTOR_H__ ++#define __GSL_PERMUTE_VECTOR_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_PERMUTE_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h (revision 14078) +@@ -0,0 +1,99 @@ ++/* statistics/gsl_statistics_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_LONG_DOUBLE_H__ ++#define __GSL_STATISTICS_LONG_DOUBLE_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_long_double_mean (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_variance (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_sd (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_variance_with_fixed_mean (const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_sd_with_fixed_mean (const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_tss (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_tss_m (const long double data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_long_double_absdev (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_skew (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_kurtosis (const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_lag1_autocorrelation (const long double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_long_double_covariance (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n); ++double gsl_stats_long_double_correlation (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_long_double_variance_m (const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_sd_m (const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_absdev_m (const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_skew_m_sd (const long double data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_long_double_kurtosis_m_sd (const long double data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_long_double_lag1_autocorrelation_m (const long double data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_long_double_covariance_m (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++/* DEFINED FOR FLOATING POINT TYPES ONLY */ ++ ++double gsl_stats_long_double_wmean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wvariance (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wsd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wvariance_with_fixed_mean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_wsd_with_fixed_mean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_long_double_wtss (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wtss_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_long_double_wabsdev (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wskew (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++double gsl_stats_long_double_wkurtosis (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_long_double_wvariance_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_long_double_wsd_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_long_double_wabsdev_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); ++double gsl_stats_long_double_wskew_m_sd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++double gsl_stats_long_double_wkurtosis_m_sd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean, const double wsd); ++ ++/* END OF FLOATING POINT TYPES */ ++ ++double gsl_stats_long_double_pvariance (const long double data1[], const size_t stride1, const size_t n1, const long double data2[], const size_t stride2, const size_t n2); ++double gsl_stats_long_double_ttest (const long double data1[], const size_t stride1, const size_t n1, const long double data2[], const size_t stride2, const size_t n2); ++ ++long double gsl_stats_long_double_max (const long double data[], const size_t stride, const size_t n); ++long double gsl_stats_long_double_min (const long double data[], const size_t stride, const size_t n); ++void gsl_stats_long_double_minmax (long double * min, long double * max, const long double data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_long_double_max_index (const long double data[], const size_t stride, const size_t n); ++size_t gsl_stats_long_double_min_index (const long double data[], const size_t stride, const size_t n); ++void gsl_stats_long_double_minmax_index (size_t * min_index, size_t * max_index, const long double data[], const size_t stride, const size_t n); ++ ++double gsl_stats_long_double_median_from_sorted_data (const long double sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_long_double_quantile_from_sorted_data (const long double sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h (revision 14078) +@@ -0,0 +1,351 @@ ++/* matrix/gsl_matrix_complex_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ ++#define __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ long double * data; ++ gsl_block_complex_long_double * block; ++ int owner; ++} gsl_matrix_complex_long_double ; ++ ++typedef struct ++{ ++ gsl_matrix_complex_long_double matrix; ++} _gsl_matrix_complex_long_double_view; ++ ++typedef _gsl_matrix_complex_long_double_view gsl_matrix_complex_long_double_view; ++ ++typedef struct ++{ ++ gsl_matrix_complex_long_double matrix; ++} _gsl_matrix_complex_long_double_const_view; ++ ++typedef const _gsl_matrix_complex_long_double_const_view gsl_matrix_complex_long_double_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_matrix_complex_long_double * ++gsl_matrix_complex_long_double_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex_long_double * ++gsl_matrix_complex_long_double_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_complex_long_double * ++gsl_matrix_complex_long_double_alloc_from_block (gsl_block_complex_long_double * b, ++ const size_t offset, ++ const size_t n1, const size_t n2, const size_t d2); ++ ++gsl_matrix_complex_long_double * ++gsl_matrix_complex_long_double_alloc_from_matrix (gsl_matrix_complex_long_double * b, ++ const size_t k1, const size_t k2, ++ const size_t n1, const size_t n2); ++ ++gsl_vector_complex_long_double * ++gsl_vector_complex_long_double_alloc_row_from_matrix (gsl_matrix_complex_long_double * m, ++ const size_t i); ++ ++gsl_vector_complex_long_double * ++gsl_vector_complex_long_double_alloc_col_from_matrix (gsl_matrix_complex_long_double * m, ++ const size_t j); ++ ++void gsl_matrix_complex_long_double_free (gsl_matrix_complex_long_double * m); ++ ++/* Views */ ++ ++_gsl_matrix_complex_long_double_view ++gsl_matrix_complex_long_double_submatrix (gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_row (gsl_matrix_complex_long_double * m, const size_t i); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_column (gsl_matrix_complex_long_double * m, const size_t j); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_diagonal (gsl_matrix_complex_long_double * m); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_subdiagonal (gsl_matrix_complex_long_double * m, const size_t k); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_superdiagonal (gsl_matrix_complex_long_double * m, const size_t k); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_subrow (gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_long_double_view ++gsl_matrix_complex_long_double_subcolumn (gsl_matrix_complex_long_double * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_long_double_view ++gsl_matrix_complex_long_double_view_array (long double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_long_double_view ++gsl_matrix_complex_long_double_view_array_with_tda (long double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_long_double_view ++gsl_matrix_complex_long_double_view_vector (gsl_vector_complex_long_double * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_long_double_view ++gsl_matrix_complex_long_double_view_vector_with_tda (gsl_vector_complex_long_double * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_submatrix (const gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_row (const gsl_matrix_complex_long_double * m, ++ const size_t i); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_column (const gsl_matrix_complex_long_double * m, ++ const size_t j); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_diagonal (const gsl_matrix_complex_long_double * m); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_subdiagonal (const gsl_matrix_complex_long_double * m, ++ const size_t k); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_superdiagonal (const gsl_matrix_complex_long_double * m, ++ const size_t k); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_subrow (const gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t offset, ++ const size_t n); ++ ++_gsl_vector_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_subcolumn (const gsl_matrix_complex_long_double * m, ++ const size_t j, const size_t offset, ++ const size_t n); ++ ++_gsl_matrix_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_view_array (const long double * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_view_array_with_tda (const long double * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_view_vector (const gsl_vector_complex_long_double * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_complex_long_double_const_view ++gsl_matrix_complex_long_double_const_view_vector_with_tda (const gsl_vector_complex_long_double * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_complex_long_double_set_zero (gsl_matrix_complex_long_double * m); ++void gsl_matrix_complex_long_double_set_identity (gsl_matrix_complex_long_double * m); ++void gsl_matrix_complex_long_double_set_all (gsl_matrix_complex_long_double * m, gsl_complex_long_double x); ++ ++int gsl_matrix_complex_long_double_fread (FILE * stream, gsl_matrix_complex_long_double * m) ; ++int gsl_matrix_complex_long_double_fwrite (FILE * stream, const gsl_matrix_complex_long_double * m) ; ++int gsl_matrix_complex_long_double_fscanf (FILE * stream, gsl_matrix_complex_long_double * m); ++int gsl_matrix_complex_long_double_fprintf (FILE * stream, const gsl_matrix_complex_long_double * m, const char * format); ++ ++int gsl_matrix_complex_long_double_memcpy(gsl_matrix_complex_long_double * dest, const gsl_matrix_complex_long_double * src); ++int gsl_matrix_complex_long_double_swap(gsl_matrix_complex_long_double * m1, gsl_matrix_complex_long_double * m2); ++ ++int gsl_matrix_complex_long_double_swap_rows(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++int gsl_matrix_complex_long_double_swap_columns(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++int gsl_matrix_complex_long_double_swap_rowcol(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++ ++int gsl_matrix_complex_long_double_transpose (gsl_matrix_complex_long_double * m); ++int gsl_matrix_complex_long_double_transpose_memcpy (gsl_matrix_complex_long_double * dest, const gsl_matrix_complex_long_double * src); ++ ++int gsl_matrix_complex_long_double_equal (const gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); ++ ++int gsl_matrix_complex_long_double_isnull (const gsl_matrix_complex_long_double * m); ++int gsl_matrix_complex_long_double_ispos (const gsl_matrix_complex_long_double * m); ++int gsl_matrix_complex_long_double_isneg (const gsl_matrix_complex_long_double * m); ++int gsl_matrix_complex_long_double_isnonneg (const gsl_matrix_complex_long_double * m); ++ ++int gsl_matrix_complex_long_double_add (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); ++int gsl_matrix_complex_long_double_sub (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); ++int gsl_matrix_complex_long_double_mul_elements (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); ++int gsl_matrix_complex_long_double_div_elements (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); ++int gsl_matrix_complex_long_double_scale (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); ++int gsl_matrix_complex_long_double_add_constant (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); ++int gsl_matrix_complex_long_double_add_diagonal (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_complex_long_double_get_row(gsl_vector_complex_long_double * v, const gsl_matrix_complex_long_double * m, const size_t i); ++int gsl_matrix_complex_long_double_get_col(gsl_vector_complex_long_double * v, const gsl_matrix_complex_long_double * m, const size_t j); ++int gsl_matrix_complex_long_double_set_row(gsl_matrix_complex_long_double * m, const size_t i, const gsl_vector_complex_long_double * v); ++int gsl_matrix_complex_long_double_set_col(gsl_matrix_complex_long_double * m, const size_t j, const gsl_vector_complex_long_double * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL gsl_complex_long_double gsl_matrix_complex_long_double_get(const gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_complex_long_double_set(gsl_matrix_complex_long_double * m, const size_t i, const size_t j, const gsl_complex_long_double x); ++ ++INLINE_DECL gsl_complex_long_double * gsl_matrix_complex_long_double_ptr(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++INLINE_DECL const gsl_complex_long_double * gsl_matrix_complex_long_double_const_ptr(const gsl_matrix_complex_long_double * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex_long_double ++gsl_matrix_complex_long_double_get(const gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ gsl_complex_long_double zero = {{0,0}}; ++ ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; ++ } ++ } ++#endif ++ return *(gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_complex_long_double_set(gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j, const gsl_complex_long_double x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ *(gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) = x ; ++} ++ ++INLINE_FUN ++gsl_complex_long_double * ++gsl_matrix_complex_long_double_ptr(gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const gsl_complex_long_double * ++gsl_matrix_complex_long_double_const_ptr(const gsl_matrix_complex_long_double * m, ++ const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; ++} ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h (revision 14078) +@@ -0,0 +1,54 @@ ++/* blas/gsl_blas_types.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* ++ * Author: G. Jungman ++ */ ++/* Based on draft BLAST C interface specification [Jul 7 1998] ++ */ ++#ifndef __GSL_BLAS_TYPES_H__ ++#define __GSL_BLAS_TYPES_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef CBLAS_INDEX CBLAS_INDEX_t; ++typedef enum CBLAS_ORDER CBLAS_ORDER_t; ++typedef enum CBLAS_TRANSPOSE CBLAS_TRANSPOSE_t; ++typedef enum CBLAS_UPLO CBLAS_UPLO_t; ++typedef enum CBLAS_DIAG CBLAS_DIAG_t; ++typedef enum CBLAS_SIDE CBLAS_SIDE_t; ++ ++/* typedef gsl_complex COMPLEX; */ ++ ++__END_DECLS ++ ++ ++#endif /* __GSL_BLAS_TYPES_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_ULONG_H__ ++#define __GSL_VECTOR_ULONG_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ unsigned long *data; ++ gsl_block_ulong *block; ++ int owner; ++} ++gsl_vector_ulong; ++ ++typedef struct ++{ ++ gsl_vector_ulong vector; ++} _gsl_vector_ulong_view; ++ ++typedef _gsl_vector_ulong_view gsl_vector_ulong_view; ++ ++typedef struct ++{ ++ gsl_vector_ulong vector; ++} _gsl_vector_ulong_const_view; ++ ++typedef const _gsl_vector_ulong_const_view gsl_vector_ulong_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_ulong *gsl_vector_ulong_alloc (const size_t n); ++gsl_vector_ulong *gsl_vector_ulong_calloc (const size_t n); ++ ++gsl_vector_ulong *gsl_vector_ulong_alloc_from_block (gsl_block_ulong * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_ulong *gsl_vector_ulong_alloc_from_vector (gsl_vector_ulong * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_ulong_free (gsl_vector_ulong * v); ++ ++/* Views */ ++ ++_gsl_vector_ulong_view ++gsl_vector_ulong_view_array (unsigned long *v, size_t n); ++ ++_gsl_vector_ulong_view ++gsl_vector_ulong_view_array_with_stride (unsigned long *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ulong_const_view ++gsl_vector_ulong_const_view_array (const unsigned long *v, size_t n); ++ ++_gsl_vector_ulong_const_view ++gsl_vector_ulong_const_view_array_with_stride (const unsigned long *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ulong_view ++gsl_vector_ulong_subvector (gsl_vector_ulong *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_ulong_view ++gsl_vector_ulong_subvector_with_stride (gsl_vector_ulong *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_ulong_const_view ++gsl_vector_ulong_const_subvector (const gsl_vector_ulong *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_ulong_const_view ++gsl_vector_ulong_const_subvector_with_stride (const gsl_vector_ulong *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_ulong_set_zero (gsl_vector_ulong * v); ++void gsl_vector_ulong_set_all (gsl_vector_ulong * v, unsigned long x); ++int gsl_vector_ulong_set_basis (gsl_vector_ulong * v, size_t i); ++ ++int gsl_vector_ulong_fread (FILE * stream, gsl_vector_ulong * v); ++int gsl_vector_ulong_fwrite (FILE * stream, const gsl_vector_ulong * v); ++int gsl_vector_ulong_fscanf (FILE * stream, gsl_vector_ulong * v); ++int gsl_vector_ulong_fprintf (FILE * stream, const gsl_vector_ulong * v, ++ const char *format); ++ ++int gsl_vector_ulong_memcpy (gsl_vector_ulong * dest, const gsl_vector_ulong * src); ++ ++int gsl_vector_ulong_reverse (gsl_vector_ulong * v); ++ ++int gsl_vector_ulong_swap (gsl_vector_ulong * v, gsl_vector_ulong * w); ++int gsl_vector_ulong_swap_elements (gsl_vector_ulong * v, const size_t i, const size_t j); ++ ++unsigned long gsl_vector_ulong_max (const gsl_vector_ulong * v); ++unsigned long gsl_vector_ulong_min (const gsl_vector_ulong * v); ++void gsl_vector_ulong_minmax (const gsl_vector_ulong * v, unsigned long * min_out, unsigned long * max_out); ++ ++size_t gsl_vector_ulong_max_index (const gsl_vector_ulong * v); ++size_t gsl_vector_ulong_min_index (const gsl_vector_ulong * v); ++void gsl_vector_ulong_minmax_index (const gsl_vector_ulong * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_ulong_add (gsl_vector_ulong * a, const gsl_vector_ulong * b); ++int gsl_vector_ulong_sub (gsl_vector_ulong * a, const gsl_vector_ulong * b); ++int gsl_vector_ulong_mul (gsl_vector_ulong * a, const gsl_vector_ulong * b); ++int gsl_vector_ulong_div (gsl_vector_ulong * a, const gsl_vector_ulong * b); ++int gsl_vector_ulong_scale (gsl_vector_ulong * a, const double x); ++int gsl_vector_ulong_add_constant (gsl_vector_ulong * a, const double x); ++ ++int gsl_vector_ulong_equal (const gsl_vector_ulong * u, ++ const gsl_vector_ulong * v); ++ ++int gsl_vector_ulong_isnull (const gsl_vector_ulong * v); ++int gsl_vector_ulong_ispos (const gsl_vector_ulong * v); ++int gsl_vector_ulong_isneg (const gsl_vector_ulong * v); ++int gsl_vector_ulong_isnonneg (const gsl_vector_ulong * v); ++ ++INLINE_DECL unsigned long gsl_vector_ulong_get (const gsl_vector_ulong * v, const size_t i); ++INLINE_DECL void gsl_vector_ulong_set (gsl_vector_ulong * v, const size_t i, unsigned long x); ++INLINE_DECL unsigned long * gsl_vector_ulong_ptr (gsl_vector_ulong * v, const size_t i); ++INLINE_DECL const unsigned long * gsl_vector_ulong_const_ptr (const gsl_vector_ulong * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++unsigned long ++gsl_vector_ulong_get (const gsl_vector_ulong * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_ulong_set (gsl_vector_ulong * v, const size_t i, unsigned long x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++unsigned long * ++gsl_vector_ulong_ptr (gsl_vector_ulong * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (unsigned long *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const unsigned long * ++gsl_vector_ulong_const_ptr (const gsl_vector_ulong * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const unsigned long *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_ULONG_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h (revision 14078) +@@ -0,0 +1,108 @@ ++/* wavelet/gsl_wavelet.h ++ * ++ * Copyright (C) 2004 Ivo Alxneit ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_WAVELET_H__ ++#define __GSL_WAVELET_H__ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++#ifndef GSL_DISABLE_DEPRECATED ++typedef enum { ++ forward = 1, backward = -1, ++ gsl_wavelet_forward = 1, gsl_wavelet_backward = -1 ++} ++gsl_wavelet_direction; ++#else ++typedef enum { ++ gsl_wavelet_forward = 1, gsl_wavelet_backward = -1 ++} ++gsl_wavelet_direction; ++#endif ++ ++typedef struct ++{ ++ const char *name; ++ int (*init) (const double **h1, const double **g1, ++ const double **h2, const double **g2, size_t * nc, ++ size_t * offset, size_t member); ++} ++gsl_wavelet_type; ++ ++typedef struct ++{ ++ const gsl_wavelet_type *type; ++ const double *h1; ++ const double *g1; ++ const double *h2; ++ const double *g2; ++ size_t nc; ++ size_t offset; ++} ++gsl_wavelet; ++ ++typedef struct ++{ ++ double *scratch; ++ size_t n; ++} ++gsl_wavelet_workspace; ++ ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_daubechies; ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_daubechies_centered; ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_haar; ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_haar_centered; ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_bspline; ++GSL_VAR const gsl_wavelet_type *gsl_wavelet_bspline_centered; ++ ++gsl_wavelet *gsl_wavelet_alloc (const gsl_wavelet_type * T, size_t k); ++void gsl_wavelet_free (gsl_wavelet * w); ++const char *gsl_wavelet_name (const gsl_wavelet * w); ++ ++gsl_wavelet_workspace *gsl_wavelet_workspace_alloc (size_t n); ++void gsl_wavelet_workspace_free (gsl_wavelet_workspace * work); ++ ++int gsl_wavelet_transform (const gsl_wavelet * w, ++ double *data, size_t stride, size_t n, ++ gsl_wavelet_direction dir, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet_transform_forward (const gsl_wavelet * w, ++ double *data, size_t stride, size_t n, ++ gsl_wavelet_workspace * work); ++ ++int gsl_wavelet_transform_inverse (const gsl_wavelet * w, ++ double *data, size_t stride, size_t n, ++ gsl_wavelet_workspace * work); ++ ++__END_DECLS ++ ++#endif /* __GSL_WAVELET_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h (revision 14078) +@@ -0,0 +1,39 @@ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_H__ ++#define __GSL_SF_H__ ++ ++#include ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++ ++#endif /* __GSL_SF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h (revision 14078) +@@ -0,0 +1,125 @@ ++/* specfunc/gsl_sf_coupling.h ++ * ++ * Copyright (C) 1996,1997,1998,1999,2000,2001,2002 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_COUPLING_H__ ++#define __GSL_SF_COUPLING_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* 3j Symbols: / ja jb jc \ ++ * \ ma mb mc / ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_coupling_3j_e(int two_ja, int two_jb, int two_jc, ++ int two_ma, int two_mb, int two_mc, ++ gsl_sf_result * result ++ ); ++double gsl_sf_coupling_3j(int two_ja, int two_jb, int two_jc, ++ int two_ma, int two_mb, int two_mc ++ ); ++ ++ ++/* 6j Symbols: / ja jb jc \ ++ * \ jd je jf / ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_coupling_6j_e(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf, ++ gsl_sf_result * result ++ ); ++double gsl_sf_coupling_6j(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf ++ ); ++ ++/* Racah W coefficients: ++ * ++ * W(a b c d; e f) = (-1)^{a+b+c+d} / a b e \ ++ * \ d c f / ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_coupling_RacahW_e(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf, ++ gsl_sf_result * result ++ ); ++double gsl_sf_coupling_RacahW(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf ++ ); ++ ++ ++/* 9j Symbols: / ja jb jc \ ++ * | jd je jf | ++ * \ jg jh ji / ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++int gsl_sf_coupling_9j_e(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf, ++ int two_jg, int two_jh, int two_ji, ++ gsl_sf_result * result ++ ); ++double gsl_sf_coupling_9j(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf, ++ int two_jg, int two_jh, int two_ji ++ ); ++ ++ ++/* INCORRECT version of 6j Symbols: ++ * This function actually calculates ++ * / ja jb je \ ++ * \ jd jc jf / ++ * It represents the original implementation, ++ * which had the above permutation of the ++ * arguments. This was wrong and confusing, ++ * and I had to fix it. Sorry for the trouble. ++ * [GJ] Tue Nov 26 12:53:39 MST 2002 ++ * ++ * exceptions: GSL_EDOM, GSL_EOVRFLW ++ */ ++#ifndef GSL_DISABLE_DEPRECATED ++int gsl_sf_coupling_6j_INCORRECT_e(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf, ++ gsl_sf_result * result ++ ); ++double gsl_sf_coupling_6j_INCORRECT(int two_ja, int two_jb, int two_jc, ++ int two_jd, int two_je, int two_jf ++ ); ++#endif /* !GSL_DISABLE_DEPRECATED */ ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_COUPLING_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_short.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_SHORT_H__ ++#define __GSL_BLOCK_SHORT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_short_struct ++{ ++ size_t size; ++ short *data; ++}; ++ ++typedef struct gsl_block_short_struct gsl_block_short; ++ ++gsl_block_short *gsl_block_short_alloc (const size_t n); ++gsl_block_short *gsl_block_short_calloc (const size_t n); ++void gsl_block_short_free (gsl_block_short * b); ++ ++int gsl_block_short_fread (FILE * stream, gsl_block_short * b); ++int gsl_block_short_fwrite (FILE * stream, const gsl_block_short * b); ++int gsl_block_short_fscanf (FILE * stream, gsl_block_short * b); ++int gsl_block_short_fprintf (FILE * stream, const gsl_block_short * b, const char *format); ++ ++int gsl_block_short_raw_fread (FILE * stream, short * b, const size_t n, const size_t stride); ++int gsl_block_short_raw_fwrite (FILE * stream, const short * b, const size_t n, const size_t stride); ++int gsl_block_short_raw_fscanf (FILE * stream, short * b, const size_t n, const size_t stride); ++int gsl_block_short_raw_fprintf (FILE * stream, const short * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_short_size (const gsl_block_short * b); ++short * gsl_block_short_data (const gsl_block_short * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h (revision 14078) +@@ -0,0 +1,20 @@ ++#ifndef __GSL_SORT_VECTOR_H__ ++#define __GSL_SORT_VECTOR_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_SORT_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h (revision 14078) +@@ -0,0 +1,51 @@ ++/* sort/gsl_sort_vector_ushort.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_VECTOR_USHORT_H__ ++#define __GSL_SORT_VECTOR_USHORT_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_vector_ushort (gsl_vector_ushort * v); ++int gsl_sort_vector_ushort_index (gsl_permutation * p, const gsl_vector_ushort * v); ++ ++int gsl_sort_vector_ushort_smallest (unsigned short * dest, const size_t k, const gsl_vector_ushort * v); ++int gsl_sort_vector_ushort_largest (unsigned short * dest, const size_t k, const gsl_vector_ushort * v); ++ ++int gsl_sort_vector_ushort_smallest_index (size_t * p, const size_t k, const gsl_vector_ushort * v); ++int gsl_sort_vector_ushort_largest_index (size_t * p, const size_t k, const gsl_vector_ushort * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_VECTOR_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h (revision 14078) +@@ -0,0 +1,177 @@ ++/* multiroots/gsl_multiroots.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MULTIROOTS_H__ ++#define __GSL_MULTIROOTS_H__ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Definition of vector-valued functions with parameters based on gsl_vector */ ++ ++struct gsl_multiroot_function_struct ++{ ++ int (* f) (const gsl_vector * x, void * params, gsl_vector * f); ++ size_t n; ++ void * params; ++}; ++ ++typedef struct gsl_multiroot_function_struct gsl_multiroot_function ; ++ ++#define GSL_MULTIROOT_FN_EVAL(F,x,y) (*((F)->f))(x,(F)->params,(y)) ++ ++int gsl_multiroot_fdjacobian (gsl_multiroot_function * F, ++ const gsl_vector * x, const gsl_vector * f, ++ double epsrel, gsl_matrix * jacobian); ++ ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n); ++ int (*set) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); ++ int (*iterate) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); ++ void (*free) (void *state); ++ } ++gsl_multiroot_fsolver_type; ++ ++typedef struct ++ { ++ const gsl_multiroot_fsolver_type * type; ++ gsl_multiroot_function * function ; ++ gsl_vector * x ; ++ gsl_vector * f ; ++ gsl_vector * dx ; ++ void *state; ++ } ++gsl_multiroot_fsolver; ++ ++gsl_multiroot_fsolver * ++gsl_multiroot_fsolver_alloc (const gsl_multiroot_fsolver_type * T, ++ size_t n); ++ ++void gsl_multiroot_fsolver_free (gsl_multiroot_fsolver * s); ++ ++int gsl_multiroot_fsolver_set (gsl_multiroot_fsolver * s, ++ gsl_multiroot_function * f, ++ const gsl_vector * x); ++ ++int gsl_multiroot_fsolver_iterate (gsl_multiroot_fsolver * s); ++ ++const char * gsl_multiroot_fsolver_name (const gsl_multiroot_fsolver * s); ++gsl_vector * gsl_multiroot_fsolver_root (const gsl_multiroot_fsolver * s); ++gsl_vector * gsl_multiroot_fsolver_dx (const gsl_multiroot_fsolver * s); ++gsl_vector * gsl_multiroot_fsolver_f (const gsl_multiroot_fsolver * s); ++ ++/* Definition of vector-valued functions and gradient with parameters ++ based on gsl_vector */ ++ ++struct gsl_multiroot_function_fdf_struct ++{ ++ int (* f) (const gsl_vector * x, void * params, gsl_vector * f); ++ int (* df) (const gsl_vector * x, void * params, gsl_matrix * df); ++ int (* fdf) (const gsl_vector * x, void * params, gsl_vector * f, gsl_matrix *df); ++ size_t n; ++ void * params; ++}; ++ ++typedef struct gsl_multiroot_function_fdf_struct gsl_multiroot_function_fdf ; ++ ++#define GSL_MULTIROOT_FN_EVAL_F(F,x,y) ((*((F)->f))(x,(F)->params,(y))) ++#define GSL_MULTIROOT_FN_EVAL_DF(F,x,dy) ((*((F)->df))(x,(F)->params,(dy))) ++#define GSL_MULTIROOT_FN_EVAL_F_DF(F,x,y,dy) ((*((F)->fdf))(x,(F)->params,(y),(dy))) ++ ++typedef struct ++ { ++ const char *name; ++ size_t size; ++ int (*alloc) (void *state, size_t n); ++ int (*set) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); ++ int (*iterate) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); ++ void (*free) (void *state); ++ } ++gsl_multiroot_fdfsolver_type; ++ ++typedef struct ++ { ++ const gsl_multiroot_fdfsolver_type * type; ++ gsl_multiroot_function_fdf * fdf ; ++ gsl_vector * x; ++ gsl_vector * f; ++ gsl_matrix * J; ++ gsl_vector * dx; ++ void *state; ++ } ++gsl_multiroot_fdfsolver; ++ ++gsl_multiroot_fdfsolver * ++gsl_multiroot_fdfsolver_alloc (const gsl_multiroot_fdfsolver_type * T, ++ size_t n); ++ ++int ++gsl_multiroot_fdfsolver_set (gsl_multiroot_fdfsolver * s, ++ gsl_multiroot_function_fdf * fdf, ++ const gsl_vector * x); ++ ++int ++gsl_multiroot_fdfsolver_iterate (gsl_multiroot_fdfsolver * s); ++ ++void ++gsl_multiroot_fdfsolver_free (gsl_multiroot_fdfsolver * s); ++ ++const char * gsl_multiroot_fdfsolver_name (const gsl_multiroot_fdfsolver * s); ++gsl_vector * gsl_multiroot_fdfsolver_root (const gsl_multiroot_fdfsolver * s); ++gsl_vector * gsl_multiroot_fdfsolver_dx (const gsl_multiroot_fdfsolver * s); ++gsl_vector * gsl_multiroot_fdfsolver_f (const gsl_multiroot_fdfsolver * s); ++ ++int gsl_multiroot_test_delta (const gsl_vector * dx, const gsl_vector * x, ++ double epsabs, double epsrel); ++ ++int gsl_multiroot_test_residual (const gsl_vector * f, double epsabs); ++ ++GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_dnewton; ++GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_broyden; ++GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrid; ++GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrids; ++ ++GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_newton; ++GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_gnewton; ++GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridj; ++GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridsj; ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_MULTIROOTS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h (revision 14078) +@@ -0,0 +1,48 @@ ++/* specfunc/gsl_sf_elljac.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_ELLJAC_H__ ++#define __GSL_SF_ELLJAC_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Jacobian elliptic functions sn, dn, cn, ++ * by descending Landen transformations ++ * ++ * exceptions: GSL_EDOM ++ */ ++int gsl_sf_elljac_e(double u, double m, double * sn, double * cn, double * dn); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_ELLJAC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h (revision 14078) +@@ -0,0 +1,606 @@ ++/* blas/gsl_cblas.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* This is a copy of the CBLAS standard header. ++ * We carry this around so we do not have to ++ * break our model for flexible BLAS functionality. ++ */ ++ ++#ifndef __GSL_CBLAS_H__ ++#define __GSL_CBLAS_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++#define __BEGIN_DECLS extern "C" { ++#define __END_DECLS } ++#else ++#define __BEGIN_DECLS /* empty */ ++#define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* ++ * Enumerated and derived types ++ */ ++#define CBLAS_INDEX size_t /* this may vary between platforms */ ++ ++enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102}; ++enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113}; ++enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}; ++enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}; ++enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; ++ ++/* ++ * =========================================================================== ++ * Prototypes for level 1 BLAS functions (complex are recast as routines) ++ * =========================================================================== ++ */ ++float cblas_sdsdot(const int N, const float alpha, const float *X, ++ const int incX, const float *Y, const int incY); ++double cblas_dsdot(const int N, const float *X, const int incX, const float *Y, ++ const int incY); ++float cblas_sdot(const int N, const float *X, const int incX, ++ const float *Y, const int incY); ++double cblas_ddot(const int N, const double *X, const int incX, ++ const double *Y, const int incY); ++ ++/* ++ * Functions having prefixes Z and C only ++ */ ++void cblas_cdotu_sub(const int N, const void *X, const int incX, ++ const void *Y, const int incY, void *dotu); ++void cblas_cdotc_sub(const int N, const void *X, const int incX, ++ const void *Y, const int incY, void *dotc); ++ ++void cblas_zdotu_sub(const int N, const void *X, const int incX, ++ const void *Y, const int incY, void *dotu); ++void cblas_zdotc_sub(const int N, const void *X, const int incX, ++ const void *Y, const int incY, void *dotc); ++ ++ ++/* ++ * Functions having prefixes S D SC DZ ++ */ ++float cblas_snrm2(const int N, const float *X, const int incX); ++float cblas_sasum(const int N, const float *X, const int incX); ++ ++double cblas_dnrm2(const int N, const double *X, const int incX); ++double cblas_dasum(const int N, const double *X, const int incX); ++ ++float cblas_scnrm2(const int N, const void *X, const int incX); ++float cblas_scasum(const int N, const void *X, const int incX); ++ ++double cblas_dznrm2(const int N, const void *X, const int incX); ++double cblas_dzasum(const int N, const void *X, const int incX); ++ ++ ++/* ++ * Functions having standard 4 prefixes (S D C Z) ++ */ ++CBLAS_INDEX cblas_isamax(const int N, const float *X, const int incX); ++CBLAS_INDEX cblas_idamax(const int N, const double *X, const int incX); ++CBLAS_INDEX cblas_icamax(const int N, const void *X, const int incX); ++CBLAS_INDEX cblas_izamax(const int N, const void *X, const int incX); ++ ++/* ++ * =========================================================================== ++ * Prototypes for level 1 BLAS routines ++ * =========================================================================== ++ */ ++ ++/* ++ * Routines with standard 4 prefixes (s, d, c, z) ++ */ ++void cblas_sswap(const int N, float *X, const int incX, ++ float *Y, const int incY); ++void cblas_scopy(const int N, const float *X, const int incX, ++ float *Y, const int incY); ++void cblas_saxpy(const int N, const float alpha, const float *X, ++ const int incX, float *Y, const int incY); ++ ++void cblas_dswap(const int N, double *X, const int incX, ++ double *Y, const int incY); ++void cblas_dcopy(const int N, const double *X, const int incX, ++ double *Y, const int incY); ++void cblas_daxpy(const int N, const double alpha, const double *X, ++ const int incX, double *Y, const int incY); ++ ++void cblas_cswap(const int N, void *X, const int incX, ++ void *Y, const int incY); ++void cblas_ccopy(const int N, const void *X, const int incX, ++ void *Y, const int incY); ++void cblas_caxpy(const int N, const void *alpha, const void *X, ++ const int incX, void *Y, const int incY); ++ ++void cblas_zswap(const int N, void *X, const int incX, ++ void *Y, const int incY); ++void cblas_zcopy(const int N, const void *X, const int incX, ++ void *Y, const int incY); ++void cblas_zaxpy(const int N, const void *alpha, const void *X, ++ const int incX, void *Y, const int incY); ++ ++ ++/* ++ * Routines with S and D prefix only ++ */ ++void cblas_srotg(float *a, float *b, float *c, float *s); ++void cblas_srotmg(float *d1, float *d2, float *b1, const float b2, float *P); ++void cblas_srot(const int N, float *X, const int incX, ++ float *Y, const int incY, const float c, const float s); ++void cblas_srotm(const int N, float *X, const int incX, ++ float *Y, const int incY, const float *P); ++ ++void cblas_drotg(double *a, double *b, double *c, double *s); ++void cblas_drotmg(double *d1, double *d2, double *b1, const double b2, double *P); ++void cblas_drot(const int N, double *X, const int incX, ++ double *Y, const int incY, const double c, const double s); ++void cblas_drotm(const int N, double *X, const int incX, ++ double *Y, const int incY, const double *P); ++ ++ ++/* ++ * Routines with S D C Z CS and ZD prefixes ++ */ ++void cblas_sscal(const int N, const float alpha, float *X, const int incX); ++void cblas_dscal(const int N, const double alpha, double *X, const int incX); ++void cblas_cscal(const int N, const void *alpha, void *X, const int incX); ++void cblas_zscal(const int N, const void *alpha, void *X, const int incX); ++void cblas_csscal(const int N, const float alpha, void *X, const int incX); ++void cblas_zdscal(const int N, const double alpha, void *X, const int incX); ++ ++/* ++ * =========================================================================== ++ * Prototypes for level 2 BLAS ++ * =========================================================================== ++ */ ++ ++/* ++ * Routines with standard 4 prefixes (S, D, C, Z) ++ */ ++void cblas_sgemv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const float alpha, const float *A, const int lda, ++ const float *X, const int incX, const float beta, ++ float *Y, const int incY); ++void cblas_sgbmv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const int KL, const int KU, const float alpha, ++ const float *A, const int lda, const float *X, ++ const int incX, const float beta, float *Y, const int incY); ++void cblas_strmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const float *A, const int lda, ++ float *X, const int incX); ++void cblas_stbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const float *A, const int lda, ++ float *X, const int incX); ++void cblas_stpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const float *Ap, float *X, const int incX); ++void cblas_strsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const float *A, const int lda, float *X, ++ const int incX); ++void cblas_stbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const float *A, const int lda, ++ float *X, const int incX); ++void cblas_stpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const float *Ap, float *X, const int incX); ++ ++void cblas_dgemv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const double alpha, const double *A, const int lda, ++ const double *X, const int incX, const double beta, ++ double *Y, const int incY); ++void cblas_dgbmv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const int KL, const int KU, const double alpha, ++ const double *A, const int lda, const double *X, ++ const int incX, const double beta, double *Y, const int incY); ++void cblas_dtrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const double *A, const int lda, ++ double *X, const int incX); ++void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const double *A, const int lda, ++ double *X, const int incX); ++void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const double *Ap, double *X, const int incX); ++void cblas_dtrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const double *A, const int lda, double *X, ++ const int incX); ++void cblas_dtbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const double *A, const int lda, ++ double *X, const int incX); ++void cblas_dtpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const double *Ap, double *X, const int incX); ++ ++void cblas_cgemv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *X, const int incX, const void *beta, ++ void *Y, const int incY); ++void cblas_cgbmv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const int KL, const int KU, const void *alpha, ++ const void *A, const int lda, const void *X, ++ const int incX, const void *beta, void *Y, const int incY); ++void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *Ap, void *X, const int incX); ++void cblas_ctrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *A, const int lda, void *X, ++ const int incX); ++void cblas_ctbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ctpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *Ap, void *X, const int incX); ++ ++void cblas_zgemv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *X, const int incX, const void *beta, ++ void *Y, const int incY); ++void cblas_zgbmv(const enum CBLAS_ORDER order, ++ const enum CBLAS_TRANSPOSE TransA, const int M, const int N, ++ const int KL, const int KU, const void *alpha, ++ const void *A, const int lda, const void *X, ++ const int incX, const void *beta, void *Y, const int incY); ++void cblas_ztrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ztbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ztpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *Ap, void *X, const int incX); ++void cblas_ztrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *A, const int lda, void *X, ++ const int incX); ++void cblas_ztbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const int K, const void *A, const int lda, ++ void *X, const int incX); ++void cblas_ztpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, ++ const int N, const void *Ap, void *X, const int incX); ++ ++ ++/* ++ * Routines with S and D prefixes only ++ */ ++void cblas_ssymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *A, ++ const int lda, const float *X, const int incX, ++ const float beta, float *Y, const int incY); ++void cblas_ssbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const int K, const float alpha, const float *A, ++ const int lda, const float *X, const int incX, ++ const float beta, float *Y, const int incY); ++void cblas_sspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *Ap, ++ const float *X, const int incX, ++ const float beta, float *Y, const int incY); ++void cblas_sger(const enum CBLAS_ORDER order, const int M, const int N, ++ const float alpha, const float *X, const int incX, ++ const float *Y, const int incY, float *A, const int lda); ++void cblas_ssyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *X, ++ const int incX, float *A, const int lda); ++void cblas_sspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *X, ++ const int incX, float *Ap); ++void cblas_ssyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *X, ++ const int incX, const float *Y, const int incY, float *A, ++ const int lda); ++void cblas_sspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const float *X, ++ const int incX, const float *Y, const int incY, float *A); ++ ++void cblas_dsymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *A, ++ const int lda, const double *X, const int incX, ++ const double beta, double *Y, const int incY); ++void cblas_dsbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const int K, const double alpha, const double *A, ++ const int lda, const double *X, const int incX, ++ const double beta, double *Y, const int incY); ++void cblas_dspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *Ap, ++ const double *X, const int incX, ++ const double beta, double *Y, const int incY); ++void cblas_dger(const enum CBLAS_ORDER order, const int M, const int N, ++ const double alpha, const double *X, const int incX, ++ const double *Y, const int incY, double *A, const int lda); ++void cblas_dsyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *X, ++ const int incX, double *A, const int lda); ++void cblas_dspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *X, ++ const int incX, double *Ap); ++void cblas_dsyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *X, ++ const int incX, const double *Y, const int incY, double *A, ++ const int lda); ++void cblas_dspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const double *X, ++ const int incX, const double *Y, const int incY, double *A); ++ ++ ++/* ++ * Routines with C and Z prefixes only ++ */ ++void cblas_chemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const void *alpha, const void *A, ++ const int lda, const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_chbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const int K, const void *alpha, const void *A, ++ const int lda, const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_chpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const void *alpha, const void *Ap, ++ const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const void *X, const int incX, ++ void *A, const int lda); ++void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const float alpha, const void *X, ++ const int incX, void *A); ++void cblas_cher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_chpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *Ap); ++ ++void cblas_zhemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const void *alpha, const void *A, ++ const int lda, const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_zhbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const int K, const void *alpha, const void *A, ++ const int lda, const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_zhpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const void *alpha, const void *Ap, ++ const void *X, const int incX, ++ const void *beta, void *Y, const int incY); ++void cblas_zgeru(const enum CBLAS_ORDER order, const int M, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_zgerc(const enum CBLAS_ORDER order, const int M, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_zher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const void *X, const int incX, ++ void *A, const int lda); ++void cblas_zhpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, ++ const int N, const double alpha, const void *X, ++ const int incX, void *A); ++void cblas_zher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *A, const int lda); ++void cblas_zhpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, ++ const void *alpha, const void *X, const int incX, ++ const void *Y, const int incY, void *Ap); ++ ++/* ++ * =========================================================================== ++ * Prototypes for level 3 BLAS ++ * =========================================================================== ++ */ ++ ++/* ++ * Routines with standard 4 prefixes (S, D, C, Z) ++ */ ++void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_TRANSPOSE TransB, const int M, const int N, ++ const int K, const float alpha, const float *A, ++ const int lda, const float *B, const int ldb, ++ const float beta, float *C, const int ldc); ++void cblas_ssymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const float alpha, const float *A, const int lda, ++ const float *B, const int ldb, const float beta, ++ float *C, const int ldc); ++void cblas_ssyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const float alpha, const float *A, const int lda, ++ const float beta, float *C, const int ldc); ++void cblas_ssyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const float alpha, const float *A, const int lda, ++ const float *B, const int ldb, const float beta, ++ float *C, const int ldc); ++void cblas_strmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const float alpha, const float *A, const int lda, ++ float *B, const int ldb); ++void cblas_strsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const float alpha, const float *A, const int lda, ++ float *B, const int ldb); ++ ++void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_TRANSPOSE TransB, const int M, const int N, ++ const int K, const double alpha, const double *A, ++ const int lda, const double *B, const int ldb, ++ const double beta, double *C, const int ldc); ++void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const double alpha, const double *A, const int lda, ++ const double *B, const int ldb, const double beta, ++ double *C, const int ldc); ++void cblas_dsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const double alpha, const double *A, const int lda, ++ const double beta, double *C, const int ldc); ++void cblas_dsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const double alpha, const double *A, const int lda, ++ const double *B, const int ldb, const double beta, ++ double *C, const int ldc); ++void cblas_dtrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const double alpha, const double *A, const int lda, ++ double *B, const int ldb); ++void cblas_dtrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const double alpha, const double *A, const int lda, ++ double *B, const int ldb); ++ ++void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_TRANSPOSE TransB, const int M, const int N, ++ const int K, const void *alpha, const void *A, ++ const int lda, const void *B, const int ldb, ++ const void *beta, void *C, const int ldc); ++void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *beta, void *C, const int ldc); ++void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ void *B, const int ldb); ++void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ void *B, const int ldb); ++ ++void cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_TRANSPOSE TransB, const int M, const int N, ++ const int K, const void *alpha, const void *A, ++ const int lda, const void *B, const int ldb, ++ const void *beta, void *C, const int ldc); ++void cblas_zsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_zsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *beta, void *C, const int ldc); ++void cblas_zsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_ztrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ void *B, const int ldb); ++void cblas_ztrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, ++ const enum CBLAS_DIAG Diag, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ void *B, const int ldb); ++ ++ ++/* ++ * Routines with prefixes C and Z only ++ */ ++void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const float alpha, const void *A, const int lda, ++ const float beta, void *C, const int ldc); ++void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const float beta, ++ void *C, const int ldc); ++ ++void cblas_zhemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, ++ const enum CBLAS_UPLO Uplo, const int M, const int N, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const void *beta, ++ void *C, const int ldc); ++void cblas_zherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const double alpha, const void *A, const int lda, ++ const double beta, void *C, const int ldc); ++void cblas_zher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, ++ const enum CBLAS_TRANSPOSE Trans, const int N, const int K, ++ const void *alpha, const void *A, const int lda, ++ const void *B, const int ldb, const double beta, ++ void *C, const int ldc); ++ ++void cblas_xerbla(int p, const char *rout, const char *form, ...); ++ ++__END_DECLS ++ ++#endif /* __GSL_CBLAS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h (revision 14078) +@@ -0,0 +1,26 @@ ++#ifndef __GSL_VERSION_H__ ++#define __GSL_VERSION_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++__BEGIN_DECLS ++ ++ ++#define GSL_VERSION "1.15" ++#define GSL_MAJOR_VERSION 1 ++#define GSL_MINOR_VERSION 15 ++ ++GSL_VAR const char * gsl_version; ++ ++__END_DECLS ++ ++#endif /* __GSL_VERSION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h (revision 14078) +@@ -0,0 +1,86 @@ ++/* fft/gsl_fft_halfcomplex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_HALFCOMPLEX_FLOAT_H__ ++#define __GSL_FFT_HALFCOMPLEX_FLOAT_H__ ++ ++#include ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_fft_halfcomplex_float_radix2_backward (float data[], const size_t stride, const size_t n); ++int gsl_fft_halfcomplex_float_radix2_inverse (float data[], const size_t stride, const size_t n); ++int gsl_fft_halfcomplex_float_radix2_transform (float data[], const size_t stride, const size_t n); ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex_float *twiddle[64]; ++ gsl_complex_float *trig; ++ } ++gsl_fft_halfcomplex_wavetable_float; ++ ++ ++gsl_fft_halfcomplex_wavetable_float * gsl_fft_halfcomplex_wavetable_float_alloc (size_t n); ++ ++void ++gsl_fft_halfcomplex_wavetable_float_free (gsl_fft_halfcomplex_wavetable_float * wavetable); ++ ++int gsl_fft_halfcomplex_float_backward (float data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable_float * wavetable, ++ gsl_fft_real_workspace_float * work); ++ ++int gsl_fft_halfcomplex_float_inverse (float data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable_float * wavetable, ++ gsl_fft_real_workspace_float * work); ++ ++int gsl_fft_halfcomplex_float_transform (float data[], const size_t stride, const size_t n, ++ const gsl_fft_halfcomplex_wavetable_float * wavetable, ++ gsl_fft_real_workspace_float * work); ++ ++int ++gsl_fft_halfcomplex_float_unpack (const float halfcomplex_coefficient[], ++ float complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++int ++gsl_fft_halfcomplex_float_radix2_unpack (const float halfcomplex_coefficient[], ++ float complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_HALFCOMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h (revision 14078) +@@ -0,0 +1,130 @@ ++/* specfunc/gsl_sf_dilog.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_DILOG_H__ ++#define __GSL_SF_DILOG_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Real part of DiLogarithm(x), for real argument. ++ * In Lewin's notation, this is Li_2(x). ++ * ++ * Li_2(x) = - Re[ Integrate[ Log[1-s] / s, {s, 0, x}] ] ++ * ++ * The function in the complex plane has a branch point ++ * at z = 1; we place the cut in the conventional way, ++ * on [1, +infty). This means that the value for real x > 1 ++ * is a matter of definition; however, this choice does not ++ * affect the real part and so is not relevant to the ++ * interpretation of this implemented function. ++ */ ++int gsl_sf_dilog_e(const double x, gsl_sf_result * result); ++double gsl_sf_dilog(const double x); ++ ++ ++/* DiLogarithm(z), for complex argument z = x + i y. ++ * Computes the principal branch. ++ * ++ * Recall that the branch cut is on the real axis with x > 1. ++ * The imaginary part of the computed value on the cut is given ++ * by -Pi*log(x), which is the limiting value taken approaching ++ * from y < 0. This is a conventional choice, though there is no ++ * true standardized choice. ++ * ++ * Note that there is no canonical way to lift the defining ++ * contour to the full Riemann surface because of the appearance ++ * of a "hidden branch point" at z = 0 on non-principal sheets. ++ * Experts will know the simple algebraic prescription for ++ * obtaining the sheet they want; non-experts will not want ++ * to know anything about it. This is why GSL chooses to compute ++ * only on the principal branch. ++ */ ++int ++gsl_sf_complex_dilog_xy_e( ++ const double x, ++ const double y, ++ gsl_sf_result * result_re, ++ gsl_sf_result * result_im ++ ); ++ ++ ++ ++/* DiLogarithm(z), for complex argument z = r Exp[i theta]. ++ * Computes the principal branch, thereby assuming an ++ * implicit reduction of theta to the range (-2 pi, 2 pi). ++ * ++ * If theta is identically zero, the imaginary part is computed ++ * as if approaching from y > 0. For other values of theta no ++ * special consideration is given, since it is assumed that ++ * no other machine representations of multiples of pi will ++ * produce y = 0 precisely. This assumption depends on some ++ * subtle properties of the machine arithmetic, such as ++ * correct rounding and monotonicity of the underlying ++ * implementation of sin() and cos(). ++ * ++ * This function is ok, but the interface is confusing since ++ * it makes it appear that the branch structure is resolved. ++ * Furthermore the handling of values close to the branch ++ * cut is subtle. Perhap this interface should be deprecated. ++ */ ++int ++gsl_sf_complex_dilog_e( ++ const double r, ++ const double theta, ++ gsl_sf_result * result_re, ++ gsl_sf_result * result_im ++ ); ++ ++ ++ ++/* Spence integral; spence(s) := Li_2(1-s) ++ * ++ * This function has a branch point at 0; we place the ++ * cut on (-infty,0). Because of our choice for the value ++ * of Li_2(z) on the cut, spence(s) is continuous as ++ * s approaches the cut from above. In other words, ++ * we define spence(x) = spence(x + i 0+). ++ */ ++int ++gsl_sf_complex_spence_xy_e( ++ const double x, ++ const double y, ++ gsl_sf_result * real_sp, ++ gsl_sf_result * imag_sp ++ ); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_DILOG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_UINT_H__ ++#define __GSL_SORT_UINT_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_uint (unsigned int * data, const size_t stride, const size_t n); ++void gsl_sort_uint_index (size_t * p, const unsigned int * data, const size_t stride, const size_t n); ++ ++int gsl_sort_uint_smallest (unsigned int * dest, const size_t k, const unsigned int * src, const size_t stride, const size_t n); ++int gsl_sort_uint_smallest_index (size_t * p, const size_t k, const unsigned int * src, const size_t stride, const size_t n); ++ ++int gsl_sort_uint_largest (unsigned int * dest, const size_t k, const unsigned int * src, const size_t stride, const size_t n); ++int gsl_sort_uint_largest_index (size_t * p, const size_t k, const unsigned int * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h (revision 14078) +@@ -0,0 +1,99 @@ ++/* ieee-utils/gsl_ieee_utils.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_IEEE_UTILS_H__ ++#define __GSL_IEEE_UTILS_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++enum { ++ GSL_IEEE_TYPE_NAN = 1, ++ GSL_IEEE_TYPE_INF = 2, ++ GSL_IEEE_TYPE_NORMAL = 3, ++ GSL_IEEE_TYPE_DENORMAL = 4, ++ GSL_IEEE_TYPE_ZERO = 5 ++} ; ++ ++typedef struct { ++ int sign ; ++ char mantissa[24] ; /* Actual bits are 0..22, element 23 is \0 */ ++ int exponent ; ++ int type ; ++} gsl_ieee_float_rep ; ++ ++typedef struct { ++ int sign ; ++ char mantissa[53] ; /* Actual bits are 0..51, element 52 is \0 */ ++ int exponent ; ++ int type ; ++} gsl_ieee_double_rep ; ++ ++ ++void gsl_ieee_printf_float (const float * x) ; ++void gsl_ieee_printf_double (const double * x) ; ++ ++void gsl_ieee_fprintf_float (FILE * stream, const float * x) ; ++void gsl_ieee_fprintf_double (FILE * stream, const double * x) ; ++ ++void gsl_ieee_float_to_rep (const float * x, gsl_ieee_float_rep * r) ; ++void gsl_ieee_double_to_rep (const double * x, gsl_ieee_double_rep * r) ; ++ ++enum { ++ GSL_IEEE_SINGLE_PRECISION = 1, ++ GSL_IEEE_DOUBLE_PRECISION = 2, ++ GSL_IEEE_EXTENDED_PRECISION = 3 ++} ; ++ ++enum { ++ GSL_IEEE_ROUND_TO_NEAREST = 1, ++ GSL_IEEE_ROUND_DOWN = 2, ++ GSL_IEEE_ROUND_UP = 3, ++ GSL_IEEE_ROUND_TO_ZERO = 4 ++} ; ++ ++enum { ++ GSL_IEEE_MASK_INVALID = 1, ++ GSL_IEEE_MASK_DENORMALIZED = 2, ++ GSL_IEEE_MASK_DIVISION_BY_ZERO = 4, ++ GSL_IEEE_MASK_OVERFLOW = 8, ++ GSL_IEEE_MASK_UNDERFLOW = 16, ++ GSL_IEEE_MASK_ALL = 31, ++ GSL_IEEE_TRAP_INEXACT = 32 ++} ; ++ ++void gsl_ieee_env_setup (void) ; ++int gsl_ieee_read_mode_string (const char * description, int * precision, ++ int * rounding, int * exception_mask) ; ++int gsl_ieee_set_mode (int precision, int rounding, int exception_mask) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_IEEE_UTILS_H__ */ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_char.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_CHAR_H__ ++#define __GSL_STATISTICS_CHAR_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_char_mean (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_variance (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_sd (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_variance_with_fixed_mean (const char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_char_sd_with_fixed_mean (const char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_char_tss (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_tss_m (const char data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_char_absdev (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_skew (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_kurtosis (const char data[], const size_t stride, const size_t n); ++double gsl_stats_char_lag1_autocorrelation (const char data[], const size_t stride, const size_t n); ++ ++double gsl_stats_char_covariance (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n); ++double gsl_stats_char_correlation (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_char_variance_m (const char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_char_sd_m (const char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_char_absdev_m (const char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_char_skew_m_sd (const char data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_char_kurtosis_m_sd (const char data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_char_lag1_autocorrelation_m (const char data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_char_covariance_m (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_char_pvariance (const char data1[], const size_t stride1, const size_t n1, const char data2[], const size_t stride2, const size_t n2); ++double gsl_stats_char_ttest (const char data1[], const size_t stride1, const size_t n1, const char data2[], const size_t stride2, const size_t n2); ++ ++char gsl_stats_char_max (const char data[], const size_t stride, const size_t n); ++char gsl_stats_char_min (const char data[], const size_t stride, const size_t n); ++void gsl_stats_char_minmax (char * min, char * max, const char data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_char_max_index (const char data[], const size_t stride, const size_t n); ++size_t gsl_stats_char_min_index (const char data[], const size_t stride, const size_t n); ++void gsl_stats_char_minmax_index (size_t * min_index, size_t * max_index, const char data[], const size_t stride, const size_t n); ++ ++double gsl_stats_char_median_from_sorted_data (const char sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_char_quantile_from_sorted_data (const char sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_FLOAT_H__ ++#define __GSL_VECTOR_FLOAT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ float *data; ++ gsl_block_float *block; ++ int owner; ++} ++gsl_vector_float; ++ ++typedef struct ++{ ++ gsl_vector_float vector; ++} _gsl_vector_float_view; ++ ++typedef _gsl_vector_float_view gsl_vector_float_view; ++ ++typedef struct ++{ ++ gsl_vector_float vector; ++} _gsl_vector_float_const_view; ++ ++typedef const _gsl_vector_float_const_view gsl_vector_float_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector_float *gsl_vector_float_alloc (const size_t n); ++gsl_vector_float *gsl_vector_float_calloc (const size_t n); ++ ++gsl_vector_float *gsl_vector_float_alloc_from_block (gsl_block_float * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_float *gsl_vector_float_alloc_from_vector (gsl_vector_float * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_float_free (gsl_vector_float * v); ++ ++/* Views */ ++ ++_gsl_vector_float_view ++gsl_vector_float_view_array (float *v, size_t n); ++ ++_gsl_vector_float_view ++gsl_vector_float_view_array_with_stride (float *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_float_const_view ++gsl_vector_float_const_view_array (const float *v, size_t n); ++ ++_gsl_vector_float_const_view ++gsl_vector_float_const_view_array_with_stride (const float *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_float_view ++gsl_vector_float_subvector (gsl_vector_float *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_float_view ++gsl_vector_float_subvector_with_stride (gsl_vector_float *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_float_const_view ++gsl_vector_float_const_subvector (const gsl_vector_float *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_float_const_view ++gsl_vector_float_const_subvector_with_stride (const gsl_vector_float *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_float_set_zero (gsl_vector_float * v); ++void gsl_vector_float_set_all (gsl_vector_float * v, float x); ++int gsl_vector_float_set_basis (gsl_vector_float * v, size_t i); ++ ++int gsl_vector_float_fread (FILE * stream, gsl_vector_float * v); ++int gsl_vector_float_fwrite (FILE * stream, const gsl_vector_float * v); ++int gsl_vector_float_fscanf (FILE * stream, gsl_vector_float * v); ++int gsl_vector_float_fprintf (FILE * stream, const gsl_vector_float * v, ++ const char *format); ++ ++int gsl_vector_float_memcpy (gsl_vector_float * dest, const gsl_vector_float * src); ++ ++int gsl_vector_float_reverse (gsl_vector_float * v); ++ ++int gsl_vector_float_swap (gsl_vector_float * v, gsl_vector_float * w); ++int gsl_vector_float_swap_elements (gsl_vector_float * v, const size_t i, const size_t j); ++ ++float gsl_vector_float_max (const gsl_vector_float * v); ++float gsl_vector_float_min (const gsl_vector_float * v); ++void gsl_vector_float_minmax (const gsl_vector_float * v, float * min_out, float * max_out); ++ ++size_t gsl_vector_float_max_index (const gsl_vector_float * v); ++size_t gsl_vector_float_min_index (const gsl_vector_float * v); ++void gsl_vector_float_minmax_index (const gsl_vector_float * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_float_add (gsl_vector_float * a, const gsl_vector_float * b); ++int gsl_vector_float_sub (gsl_vector_float * a, const gsl_vector_float * b); ++int gsl_vector_float_mul (gsl_vector_float * a, const gsl_vector_float * b); ++int gsl_vector_float_div (gsl_vector_float * a, const gsl_vector_float * b); ++int gsl_vector_float_scale (gsl_vector_float * a, const double x); ++int gsl_vector_float_add_constant (gsl_vector_float * a, const double x); ++ ++int gsl_vector_float_equal (const gsl_vector_float * u, ++ const gsl_vector_float * v); ++ ++int gsl_vector_float_isnull (const gsl_vector_float * v); ++int gsl_vector_float_ispos (const gsl_vector_float * v); ++int gsl_vector_float_isneg (const gsl_vector_float * v); ++int gsl_vector_float_isnonneg (const gsl_vector_float * v); ++ ++INLINE_DECL float gsl_vector_float_get (const gsl_vector_float * v, const size_t i); ++INLINE_DECL void gsl_vector_float_set (gsl_vector_float * v, const size_t i, float x); ++INLINE_DECL float * gsl_vector_float_ptr (gsl_vector_float * v, const size_t i); ++INLINE_DECL const float * gsl_vector_float_const_ptr (const gsl_vector_float * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++float ++gsl_vector_float_get (const gsl_vector_float * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_float_set (gsl_vector_float * v, const size_t i, float x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++float * ++gsl_vector_float_ptr (gsl_vector_float * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (float *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const float * ++gsl_vector_float_const_ptr (const gsl_vector_float * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const float *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_FLOAT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_UINT_H__ ++#define __GSL_BLOCK_UINT_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_uint_struct ++{ ++ size_t size; ++ unsigned int *data; ++}; ++ ++typedef struct gsl_block_uint_struct gsl_block_uint; ++ ++gsl_block_uint *gsl_block_uint_alloc (const size_t n); ++gsl_block_uint *gsl_block_uint_calloc (const size_t n); ++void gsl_block_uint_free (gsl_block_uint * b); ++ ++int gsl_block_uint_fread (FILE * stream, gsl_block_uint * b); ++int gsl_block_uint_fwrite (FILE * stream, const gsl_block_uint * b); ++int gsl_block_uint_fscanf (FILE * stream, gsl_block_uint * b); ++int gsl_block_uint_fprintf (FILE * stream, const gsl_block_uint * b, const char *format); ++ ++int gsl_block_uint_raw_fread (FILE * stream, unsigned int * b, const size_t n, const size_t stride); ++int gsl_block_uint_raw_fwrite (FILE * stream, const unsigned int * b, const size_t n, const size_t stride); ++int gsl_block_uint_raw_fscanf (FILE * stream, unsigned int * b, const size_t n, const size_t stride); ++int gsl_block_uint_raw_fprintf (FILE * stream, const unsigned int * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_uint_size (const gsl_block_uint * b); ++unsigned int * gsl_block_uint_data (const gsl_block_uint * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h (revision 14078) +@@ -0,0 +1,20 @@ ++#ifndef __GSL_STATISTICS_H__ ++#define __GSL_STATISTICS_H__ ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#include ++#include ++ ++#endif /* __GSL_STATISTICS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h (revision 14078) +@@ -0,0 +1,139 @@ ++/* fft/gsl_fft_complex_float.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_COMPLEX_FLOAT_H__ ++#define __GSL_FFT_COMPLEX_FLOAT_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Power of 2 routines */ ++ ++ ++int gsl_fft_complex_float_radix2_forward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_backward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_inverse (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_transform (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_direction sign); ++ ++int gsl_fft_complex_float_radix2_dif_forward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_dif_backward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_dif_inverse (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n); ++ ++int gsl_fft_complex_float_radix2_dif_transform (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_direction sign); ++ ++/* Mixed Radix general-N routines */ ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex_float *twiddle[64]; ++ gsl_complex_float *trig; ++ } ++gsl_fft_complex_wavetable_float; ++ ++typedef struct ++{ ++ size_t n; ++ float *scratch; ++} ++gsl_fft_complex_workspace_float; ++ ++ ++gsl_fft_complex_wavetable_float *gsl_fft_complex_wavetable_float_alloc (size_t n); ++ ++void gsl_fft_complex_wavetable_float_free (gsl_fft_complex_wavetable_float * wavetable); ++ ++gsl_fft_complex_workspace_float *gsl_fft_complex_workspace_float_alloc (size_t n); ++ ++void gsl_fft_complex_workspace_float_free (gsl_fft_complex_workspace_float * workspace); ++ ++ ++int gsl_fft_complex_float_memcpy (gsl_fft_complex_wavetable_float * dest, ++ gsl_fft_complex_wavetable_float * src); ++ ++ ++int gsl_fft_complex_float_forward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable_float * wavetable, ++ gsl_fft_complex_workspace_float * work); ++ ++int gsl_fft_complex_float_backward (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable_float * wavetable, ++ gsl_fft_complex_workspace_float * work); ++ ++int gsl_fft_complex_float_inverse (gsl_complex_packed_array_float data, ++ const size_t stride, ++ const size_t n, ++ const gsl_fft_complex_wavetable_float * wavetable, ++ gsl_fft_complex_workspace_float * work); ++ ++int gsl_fft_complex_float_transform (gsl_complex_packed_array_float data, ++ const size_t stride, const size_t n, ++ const gsl_fft_complex_wavetable_float * wavetable, ++ gsl_fft_complex_workspace_float * work, ++ const gsl_fft_direction sign); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_COMPLEX_FLOAT_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h (revision 14078) +@@ -0,0 +1,126 @@ ++/* specfunc/gsl_sf_fermi_dirac.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++#ifndef __GSL_SF_FERMI_DIRAC_H__ ++#define __GSL_SF_FERMI_DIRAC_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Complete Fermi-Dirac Integrals: ++ * ++ * F_j(x) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,0,Infinity}] ++ * ++ * ++ * Incomplete Fermi-Dirac Integrals: ++ * ++ * F_j(x,b) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,b,Infinity}] ++ */ ++ ++ ++/* Complete integral F_{-1}(x) = e^x / (1 + e^x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_fermi_dirac_m1_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_m1(const double x); ++ ++ ++/* Complete integral F_0(x) = ln(1 + e^x) ++ * ++ * exceptions: GSL_EUNDRFLW ++ */ ++int gsl_sf_fermi_dirac_0_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_0(const double x); ++ ++ ++/* Complete integral F_1(x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_1_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_1(const double x); ++ ++ ++/* Complete integral F_2(x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_2_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_2(const double x); ++ ++ ++/* Complete integral F_j(x) ++ * for integer j ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_int_e(const int j, const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_int(const int j, const double x); ++ ++ ++/* Complete integral F_{-1/2}(x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_mhalf_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_mhalf(const double x); ++ ++ ++/* Complete integral F_{1/2}(x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_half_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_half(const double x); ++ ++ ++/* Complete integral F_{3/2}(x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW ++ */ ++int gsl_sf_fermi_dirac_3half_e(const double x, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_3half(const double x); ++ ++ ++/* Incomplete integral F_0(x,b) = ln(1 + e^(b-x)) - (b-x) ++ * ++ * exceptions: GSL_EUNDRFLW, GSL_EDOM ++ */ ++int gsl_sf_fermi_dirac_inc_0_e(const double x, const double b, gsl_sf_result * result); ++double gsl_sf_fermi_dirac_inc_0(const double x, const double b); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_SF_FERMI_DIRAC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h (revision 14078) +@@ -0,0 +1,230 @@ ++/* vector/gsl_vector_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_DOUBLE_H__ ++#define __GSL_VECTOR_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ double *data; ++ gsl_block *block; ++ int owner; ++} ++gsl_vector; ++ ++typedef struct ++{ ++ gsl_vector vector; ++} _gsl_vector_view; ++ ++typedef _gsl_vector_view gsl_vector_view; ++ ++typedef struct ++{ ++ gsl_vector vector; ++} _gsl_vector_const_view; ++ ++typedef const _gsl_vector_const_view gsl_vector_const_view; ++ ++ ++/* Allocation */ ++ ++gsl_vector *gsl_vector_alloc (const size_t n); ++gsl_vector *gsl_vector_calloc (const size_t n); ++ ++gsl_vector *gsl_vector_alloc_from_block (gsl_block * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector *gsl_vector_alloc_from_vector (gsl_vector * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_free (gsl_vector * v); ++ ++/* Views */ ++ ++_gsl_vector_view ++gsl_vector_view_array (double *v, size_t n); ++ ++_gsl_vector_view ++gsl_vector_view_array_with_stride (double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_const_view ++gsl_vector_const_view_array (const double *v, size_t n); ++ ++_gsl_vector_const_view ++gsl_vector_const_view_array_with_stride (const double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_view ++gsl_vector_subvector (gsl_vector *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_view ++gsl_vector_subvector_with_stride (gsl_vector *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_const_view ++gsl_vector_const_subvector (const gsl_vector *v, ++ size_t i, ++ size_t n); ++ ++_gsl_vector_const_view ++gsl_vector_const_subvector_with_stride (const gsl_vector *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++/* Operations */ ++ ++void gsl_vector_set_zero (gsl_vector * v); ++void gsl_vector_set_all (gsl_vector * v, double x); ++int gsl_vector_set_basis (gsl_vector * v, size_t i); ++ ++int gsl_vector_fread (FILE * stream, gsl_vector * v); ++int gsl_vector_fwrite (FILE * stream, const gsl_vector * v); ++int gsl_vector_fscanf (FILE * stream, gsl_vector * v); ++int gsl_vector_fprintf (FILE * stream, const gsl_vector * v, ++ const char *format); ++ ++int gsl_vector_memcpy (gsl_vector * dest, const gsl_vector * src); ++ ++int gsl_vector_reverse (gsl_vector * v); ++ ++int gsl_vector_swap (gsl_vector * v, gsl_vector * w); ++int gsl_vector_swap_elements (gsl_vector * v, const size_t i, const size_t j); ++ ++double gsl_vector_max (const gsl_vector * v); ++double gsl_vector_min (const gsl_vector * v); ++void gsl_vector_minmax (const gsl_vector * v, double * min_out, double * max_out); ++ ++size_t gsl_vector_max_index (const gsl_vector * v); ++size_t gsl_vector_min_index (const gsl_vector * v); ++void gsl_vector_minmax_index (const gsl_vector * v, size_t * imin, size_t * imax); ++ ++int gsl_vector_add (gsl_vector * a, const gsl_vector * b); ++int gsl_vector_sub (gsl_vector * a, const gsl_vector * b); ++int gsl_vector_mul (gsl_vector * a, const gsl_vector * b); ++int gsl_vector_div (gsl_vector * a, const gsl_vector * b); ++int gsl_vector_scale (gsl_vector * a, const double x); ++int gsl_vector_add_constant (gsl_vector * a, const double x); ++ ++int gsl_vector_equal (const gsl_vector * u, ++ const gsl_vector * v); ++ ++int gsl_vector_isnull (const gsl_vector * v); ++int gsl_vector_ispos (const gsl_vector * v); ++int gsl_vector_isneg (const gsl_vector * v); ++int gsl_vector_isnonneg (const gsl_vector * v); ++ ++INLINE_DECL double gsl_vector_get (const gsl_vector * v, const size_t i); ++INLINE_DECL void gsl_vector_set (gsl_vector * v, const size_t i, double x); ++INLINE_DECL double * gsl_vector_ptr (gsl_vector * v, const size_t i); ++INLINE_DECL const double * gsl_vector_const_ptr (const gsl_vector * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++double ++gsl_vector_get (const gsl_vector * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); ++ } ++#endif ++ return v->data[i * v->stride]; ++} ++ ++INLINE_FUN ++void ++gsl_vector_set (gsl_vector * v, const size_t i, double x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ v->data[i * v->stride] = x; ++} ++ ++INLINE_FUN ++double * ++gsl_vector_ptr (gsl_vector * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (double *) (v->data + i * v->stride); ++} ++ ++INLINE_FUN ++const double * ++gsl_vector_const_ptr (const gsl_vector * v, const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return (const double *) (v->data + i * v->stride); ++} ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_DOUBLE_H__ */ ++ ++ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_long_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_LONG_DOUBLE_H__ ++#define __GSL_SORT_LONG_DOUBLE_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_long_double (long double * data, const size_t stride, const size_t n); ++void gsl_sort_long_double_index (size_t * p, const long double * data, const size_t stride, const size_t n); ++ ++int gsl_sort_long_double_smallest (long double * dest, const size_t k, const long double * src, const size_t stride, const size_t n); ++int gsl_sort_long_double_smallest_index (size_t * p, const size_t k, const long double * src, const size_t stride, const size_t n); ++ ++int gsl_sort_long_double_largest (long double * dest, const size_t k, const long double * src, const size_t stride, const size_t n); ++int gsl_sort_long_double_largest_index (size_t * p, const size_t k, const long double * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h (revision 14078) +@@ -0,0 +1,126 @@ ++/* const/gsl_const_mksa.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, ++ * 2006, 2007, 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST_MKSA__ ++#define __GSL_CONST_MKSA__ ++ ++#define GSL_CONST_MKSA_SPEED_OF_LIGHT (2.99792458e8) /* m / s */ ++#define GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT (6.673e-11) /* m^3 / kg s^2 */ ++#define GSL_CONST_MKSA_PLANCKS_CONSTANT_H (6.62606896e-34) /* kg m^2 / s */ ++#define GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR (1.05457162825e-34) /* kg m^2 / s */ ++#define GSL_CONST_MKSA_ASTRONOMICAL_UNIT (1.49597870691e11) /* m */ ++#define GSL_CONST_MKSA_LIGHT_YEAR (9.46053620707e15) /* m */ ++#define GSL_CONST_MKSA_PARSEC (3.08567758135e16) /* m */ ++#define GSL_CONST_MKSA_GRAV_ACCEL (9.80665e0) /* m / s^2 */ ++#define GSL_CONST_MKSA_ELECTRON_VOLT (1.602176487e-19) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_MASS_ELECTRON (9.10938188e-31) /* kg */ ++#define GSL_CONST_MKSA_MASS_MUON (1.88353109e-28) /* kg */ ++#define GSL_CONST_MKSA_MASS_PROTON (1.67262158e-27) /* kg */ ++#define GSL_CONST_MKSA_MASS_NEUTRON (1.67492716e-27) /* kg */ ++#define GSL_CONST_MKSA_RYDBERG (2.17987196968e-18) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_BOLTZMANN (1.3806504e-23) /* kg m^2 / K s^2 */ ++#define GSL_CONST_MKSA_MOLAR_GAS (8.314472e0) /* kg m^2 / K mol s^2 */ ++#define GSL_CONST_MKSA_STANDARD_GAS_VOLUME (2.2710981e-2) /* m^3 / mol */ ++#define GSL_CONST_MKSA_MINUTE (6e1) /* s */ ++#define GSL_CONST_MKSA_HOUR (3.6e3) /* s */ ++#define GSL_CONST_MKSA_DAY (8.64e4) /* s */ ++#define GSL_CONST_MKSA_WEEK (6.048e5) /* s */ ++#define GSL_CONST_MKSA_INCH (2.54e-2) /* m */ ++#define GSL_CONST_MKSA_FOOT (3.048e-1) /* m */ ++#define GSL_CONST_MKSA_YARD (9.144e-1) /* m */ ++#define GSL_CONST_MKSA_MILE (1.609344e3) /* m */ ++#define GSL_CONST_MKSA_NAUTICAL_MILE (1.852e3) /* m */ ++#define GSL_CONST_MKSA_FATHOM (1.8288e0) /* m */ ++#define GSL_CONST_MKSA_MIL (2.54e-5) /* m */ ++#define GSL_CONST_MKSA_POINT (3.52777777778e-4) /* m */ ++#define GSL_CONST_MKSA_TEXPOINT (3.51459803515e-4) /* m */ ++#define GSL_CONST_MKSA_MICRON (1e-6) /* m */ ++#define GSL_CONST_MKSA_ANGSTROM (1e-10) /* m */ ++#define GSL_CONST_MKSA_HECTARE (1e4) /* m^2 */ ++#define GSL_CONST_MKSA_ACRE (4.04685642241e3) /* m^2 */ ++#define GSL_CONST_MKSA_BARN (1e-28) /* m^2 */ ++#define GSL_CONST_MKSA_LITER (1e-3) /* m^3 */ ++#define GSL_CONST_MKSA_US_GALLON (3.78541178402e-3) /* m^3 */ ++#define GSL_CONST_MKSA_QUART (9.46352946004e-4) /* m^3 */ ++#define GSL_CONST_MKSA_PINT (4.73176473002e-4) /* m^3 */ ++#define GSL_CONST_MKSA_CUP (2.36588236501e-4) /* m^3 */ ++#define GSL_CONST_MKSA_FLUID_OUNCE (2.95735295626e-5) /* m^3 */ ++#define GSL_CONST_MKSA_TABLESPOON (1.47867647813e-5) /* m^3 */ ++#define GSL_CONST_MKSA_TEASPOON (4.92892159375e-6) /* m^3 */ ++#define GSL_CONST_MKSA_CANADIAN_GALLON (4.54609e-3) /* m^3 */ ++#define GSL_CONST_MKSA_UK_GALLON (4.546092e-3) /* m^3 */ ++#define GSL_CONST_MKSA_MILES_PER_HOUR (4.4704e-1) /* m / s */ ++#define GSL_CONST_MKSA_KILOMETERS_PER_HOUR (2.77777777778e-1) /* m / s */ ++#define GSL_CONST_MKSA_KNOT (5.14444444444e-1) /* m / s */ ++#define GSL_CONST_MKSA_POUND_MASS (4.5359237e-1) /* kg */ ++#define GSL_CONST_MKSA_OUNCE_MASS (2.8349523125e-2) /* kg */ ++#define GSL_CONST_MKSA_TON (9.0718474e2) /* kg */ ++#define GSL_CONST_MKSA_METRIC_TON (1e3) /* kg */ ++#define GSL_CONST_MKSA_UK_TON (1.0160469088e3) /* kg */ ++#define GSL_CONST_MKSA_TROY_OUNCE (3.1103475e-2) /* kg */ ++#define GSL_CONST_MKSA_CARAT (2e-4) /* kg */ ++#define GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS (1.660538782e-27) /* kg */ ++#define GSL_CONST_MKSA_GRAM_FORCE (9.80665e-3) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_POUND_FORCE (4.44822161526e0) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_KILOPOUND_FORCE (4.44822161526e3) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_POUNDAL (1.38255e-1) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_CALORIE (4.1868e0) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_BTU (1.05505585262e3) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_THERM (1.05506e8) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_HORSEPOWER (7.457e2) /* kg m^2 / s^3 */ ++#define GSL_CONST_MKSA_BAR (1e5) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_STD_ATMOSPHERE (1.01325e5) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_TORR (1.33322368421e2) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_METER_OF_MERCURY (1.33322368421e5) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_INCH_OF_MERCURY (3.38638815789e3) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_INCH_OF_WATER (2.490889e2) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_PSI (6.89475729317e3) /* kg / m s^2 */ ++#define GSL_CONST_MKSA_POISE (1e-1) /* kg m^-1 s^-1 */ ++#define GSL_CONST_MKSA_STOKES (1e-4) /* m^2 / s */ ++#define GSL_CONST_MKSA_STILB (1e4) /* cd / m^2 */ ++#define GSL_CONST_MKSA_LUMEN (1e0) /* cd sr */ ++#define GSL_CONST_MKSA_LUX (1e0) /* cd sr / m^2 */ ++#define GSL_CONST_MKSA_PHOT (1e4) /* cd sr / m^2 */ ++#define GSL_CONST_MKSA_FOOTCANDLE (1.076e1) /* cd sr / m^2 */ ++#define GSL_CONST_MKSA_LAMBERT (1e4) /* cd sr / m^2 */ ++#define GSL_CONST_MKSA_FOOTLAMBERT (1.07639104e1) /* cd sr / m^2 */ ++#define GSL_CONST_MKSA_CURIE (3.7e10) /* 1 / s */ ++#define GSL_CONST_MKSA_ROENTGEN (2.58e-4) /* A s / kg */ ++#define GSL_CONST_MKSA_RAD (1e-2) /* m^2 / s^2 */ ++#define GSL_CONST_MKSA_SOLAR_MASS (1.98892e30) /* kg */ ++#define GSL_CONST_MKSA_BOHR_RADIUS (5.291772083e-11) /* m */ ++#define GSL_CONST_MKSA_NEWTON (1e0) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_DYNE (1e-5) /* kg m / s^2 */ ++#define GSL_CONST_MKSA_JOULE (1e0) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_ERG (1e-7) /* kg m^2 / s^2 */ ++#define GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-8) /* kg / K^4 s^3 */ ++#define GSL_CONST_MKSA_THOMSON_CROSS_SECTION (6.65245893699e-29) /* m^2 */ ++#define GSL_CONST_MKSA_BOHR_MAGNETON (9.27400899e-24) /* A m^2 */ ++#define GSL_CONST_MKSA_NUCLEAR_MAGNETON (5.05078317e-27) /* A m^2 */ ++#define GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT (9.28476362e-24) /* A m^2 */ ++#define GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT (1.410606633e-26) /* A m^2 */ ++#define GSL_CONST_MKSA_FARADAY (9.64853429775e4) /* A s / mol */ ++#define GSL_CONST_MKSA_ELECTRON_CHARGE (1.602176487e-19) /* A s */ ++#define GSL_CONST_MKSA_VACUUM_PERMITTIVITY (8.854187817e-12) /* A^2 s^4 / kg m^3 */ ++#define GSL_CONST_MKSA_VACUUM_PERMEABILITY (1.25663706144e-6) /* kg m / A^2 s^2 */ ++#define GSL_CONST_MKSA_DEBYE (3.33564095198e-30) /* A s^2 / m^2 */ ++#define GSL_CONST_MKSA_GAUSS (1e-4) /* kg / A s^2 */ ++ ++#endif /* __GSL_CONST_MKSA__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_uint.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_UINT_H__ ++#define __GSL_MATRIX_UINT_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ unsigned int * data; ++ gsl_block_uint * block; ++ int owner; ++} gsl_matrix_uint; ++ ++typedef struct ++{ ++ gsl_matrix_uint matrix; ++} _gsl_matrix_uint_view; ++ ++typedef _gsl_matrix_uint_view gsl_matrix_uint_view; ++ ++typedef struct ++{ ++ gsl_matrix_uint matrix; ++} _gsl_matrix_uint_const_view; ++ ++typedef const _gsl_matrix_uint_const_view gsl_matrix_uint_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_uint * ++gsl_matrix_uint_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_uint * ++gsl_matrix_uint_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_uint * ++gsl_matrix_uint_alloc_from_block (gsl_block_uint * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_uint * ++gsl_matrix_uint_alloc_from_matrix (gsl_matrix_uint * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_uint * ++gsl_vector_uint_alloc_row_from_matrix (gsl_matrix_uint * m, ++ const size_t i); ++ ++gsl_vector_uint * ++gsl_vector_uint_alloc_col_from_matrix (gsl_matrix_uint * m, ++ const size_t j); ++ ++void gsl_matrix_uint_free (gsl_matrix_uint * m); ++ ++/* Views */ ++ ++_gsl_matrix_uint_view ++gsl_matrix_uint_submatrix (gsl_matrix_uint * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_row (gsl_matrix_uint * m, const size_t i); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_column (gsl_matrix_uint * m, const size_t j); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_diagonal (gsl_matrix_uint * m); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_subdiagonal (gsl_matrix_uint * m, const size_t k); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_superdiagonal (gsl_matrix_uint * m, const size_t k); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_subrow (gsl_matrix_uint * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_uint_view ++gsl_matrix_uint_subcolumn (gsl_matrix_uint * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_uint_view ++gsl_matrix_uint_view_array (unsigned int * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uint_view ++gsl_matrix_uint_view_array_with_tda (unsigned int * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_uint_view ++gsl_matrix_uint_view_vector (gsl_vector_uint * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uint_view ++gsl_matrix_uint_view_vector_with_tda (gsl_vector_uint * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_uint_const_view ++gsl_matrix_uint_const_submatrix (const gsl_matrix_uint * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_row (const gsl_matrix_uint * m, ++ const size_t i); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_column (const gsl_matrix_uint * m, ++ const size_t j); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_diagonal (const gsl_matrix_uint * m); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_subdiagonal (const gsl_matrix_uint * m, ++ const size_t k); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_superdiagonal (const gsl_matrix_uint * m, ++ const size_t k); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_subrow (const gsl_matrix_uint * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_uint_const_view ++gsl_matrix_uint_const_subcolumn (const gsl_matrix_uint * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_uint_const_view ++gsl_matrix_uint_const_view_array (const unsigned int * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uint_const_view ++gsl_matrix_uint_const_view_array_with_tda (const unsigned int * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_uint_const_view ++gsl_matrix_uint_const_view_vector (const gsl_vector_uint * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_uint_const_view ++gsl_matrix_uint_const_view_vector_with_tda (const gsl_vector_uint * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_uint_set_zero (gsl_matrix_uint * m); ++void gsl_matrix_uint_set_identity (gsl_matrix_uint * m); ++void gsl_matrix_uint_set_all (gsl_matrix_uint * m, unsigned int x); ++ ++int gsl_matrix_uint_fread (FILE * stream, gsl_matrix_uint * m) ; ++int gsl_matrix_uint_fwrite (FILE * stream, const gsl_matrix_uint * m) ; ++int gsl_matrix_uint_fscanf (FILE * stream, gsl_matrix_uint * m); ++int gsl_matrix_uint_fprintf (FILE * stream, const gsl_matrix_uint * m, const char * format); ++ ++int gsl_matrix_uint_memcpy(gsl_matrix_uint * dest, const gsl_matrix_uint * src); ++int gsl_matrix_uint_swap(gsl_matrix_uint * m1, gsl_matrix_uint * m2); ++ ++int gsl_matrix_uint_swap_rows(gsl_matrix_uint * m, const size_t i, const size_t j); ++int gsl_matrix_uint_swap_columns(gsl_matrix_uint * m, const size_t i, const size_t j); ++int gsl_matrix_uint_swap_rowcol(gsl_matrix_uint * m, const size_t i, const size_t j); ++int gsl_matrix_uint_transpose (gsl_matrix_uint * m); ++int gsl_matrix_uint_transpose_memcpy (gsl_matrix_uint * dest, const gsl_matrix_uint * src); ++ ++unsigned int gsl_matrix_uint_max (const gsl_matrix_uint * m); ++unsigned int gsl_matrix_uint_min (const gsl_matrix_uint * m); ++void gsl_matrix_uint_minmax (const gsl_matrix_uint * m, unsigned int * min_out, unsigned int * max_out); ++ ++void gsl_matrix_uint_max_index (const gsl_matrix_uint * m, size_t * imax, size_t *jmax); ++void gsl_matrix_uint_min_index (const gsl_matrix_uint * m, size_t * imin, size_t *jmin); ++void gsl_matrix_uint_minmax_index (const gsl_matrix_uint * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_uint_equal (const gsl_matrix_uint * a, const gsl_matrix_uint * b); ++ ++int gsl_matrix_uint_isnull (const gsl_matrix_uint * m); ++int gsl_matrix_uint_ispos (const gsl_matrix_uint * m); ++int gsl_matrix_uint_isneg (const gsl_matrix_uint * m); ++int gsl_matrix_uint_isnonneg (const gsl_matrix_uint * m); ++ ++int gsl_matrix_uint_add (gsl_matrix_uint * a, const gsl_matrix_uint * b); ++int gsl_matrix_uint_sub (gsl_matrix_uint * a, const gsl_matrix_uint * b); ++int gsl_matrix_uint_mul_elements (gsl_matrix_uint * a, const gsl_matrix_uint * b); ++int gsl_matrix_uint_div_elements (gsl_matrix_uint * a, const gsl_matrix_uint * b); ++int gsl_matrix_uint_scale (gsl_matrix_uint * a, const double x); ++int gsl_matrix_uint_add_constant (gsl_matrix_uint * a, const double x); ++int gsl_matrix_uint_add_diagonal (gsl_matrix_uint * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_uint_get_row(gsl_vector_uint * v, const gsl_matrix_uint * m, const size_t i); ++int gsl_matrix_uint_get_col(gsl_vector_uint * v, const gsl_matrix_uint * m, const size_t j); ++int gsl_matrix_uint_set_row(gsl_matrix_uint * m, const size_t i, const gsl_vector_uint * v); ++int gsl_matrix_uint_set_col(gsl_matrix_uint * m, const size_t j, const gsl_vector_uint * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL unsigned int gsl_matrix_uint_get(const gsl_matrix_uint * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_uint_set(gsl_matrix_uint * m, const size_t i, const size_t j, const unsigned int x); ++INLINE_DECL unsigned int * gsl_matrix_uint_ptr(gsl_matrix_uint * m, const size_t i, const size_t j); ++INLINE_DECL const unsigned int * gsl_matrix_uint_const_ptr(const gsl_matrix_uint * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++unsigned int ++gsl_matrix_uint_get(const gsl_matrix_uint * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_uint_set(gsl_matrix_uint * m, const size_t i, const size_t j, const unsigned int x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++unsigned int * ++gsl_matrix_uint_ptr(gsl_matrix_uint * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (unsigned int *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const unsigned int * ++gsl_matrix_uint_const_ptr(const gsl_matrix_uint * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const unsigned int *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h (revision 14078) +@@ -0,0 +1,185 @@ ++/* randist/gsl_randist.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 James Theiler, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_RANDIST_H__ ++#define __GSL_RANDIST_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++unsigned int gsl_ran_bernoulli (const gsl_rng * r, double p); ++double gsl_ran_bernoulli_pdf (const unsigned int k, double p); ++ ++double gsl_ran_beta (const gsl_rng * r, const double a, const double b); ++double gsl_ran_beta_pdf (const double x, const double a, const double b); ++ ++unsigned int gsl_ran_binomial (const gsl_rng * r, double p, unsigned int n); ++unsigned int gsl_ran_binomial_knuth (const gsl_rng * r, double p, unsigned int n); ++unsigned int gsl_ran_binomial_tpe (const gsl_rng * r, double p, unsigned int n); ++double gsl_ran_binomial_pdf (const unsigned int k, const double p, const unsigned int n); ++ ++double gsl_ran_exponential (const gsl_rng * r, const double mu); ++double gsl_ran_exponential_pdf (const double x, const double mu); ++ ++double gsl_ran_exppow (const gsl_rng * r, const double a, const double b); ++double gsl_ran_exppow_pdf (const double x, const double a, const double b); ++ ++double gsl_ran_cauchy (const gsl_rng * r, const double a); ++double gsl_ran_cauchy_pdf (const double x, const double a); ++ ++double gsl_ran_chisq (const gsl_rng * r, const double nu); ++double gsl_ran_chisq_pdf (const double x, const double nu); ++ ++void gsl_ran_dirichlet (const gsl_rng * r, const size_t K, const double alpha[], double theta[]); ++double gsl_ran_dirichlet_pdf (const size_t K, const double alpha[], const double theta[]); ++double gsl_ran_dirichlet_lnpdf (const size_t K, const double alpha[], const double theta[]); ++ ++double gsl_ran_erlang (const gsl_rng * r, const double a, const double n); ++double gsl_ran_erlang_pdf (const double x, const double a, const double n); ++ ++double gsl_ran_fdist (const gsl_rng * r, const double nu1, const double nu2); ++double gsl_ran_fdist_pdf (const double x, const double nu1, const double nu2); ++ ++double gsl_ran_flat (const gsl_rng * r, const double a, const double b); ++double gsl_ran_flat_pdf (double x, const double a, const double b); ++ ++double gsl_ran_gamma (const gsl_rng * r, const double a, const double b); ++double gsl_ran_gamma_int (const gsl_rng * r, const unsigned int a); ++double gsl_ran_gamma_pdf (const double x, const double a, const double b); ++double gsl_ran_gamma_mt (const gsl_rng * r, const double a, const double b); ++double gsl_ran_gamma_knuth (const gsl_rng * r, const double a, const double b); ++ ++double gsl_ran_gaussian (const gsl_rng * r, const double sigma); ++double gsl_ran_gaussian_ratio_method (const gsl_rng * r, const double sigma); ++double gsl_ran_gaussian_ziggurat (const gsl_rng * r, const double sigma); ++double gsl_ran_gaussian_pdf (const double x, const double sigma); ++ ++double gsl_ran_ugaussian (const gsl_rng * r); ++double gsl_ran_ugaussian_ratio_method (const gsl_rng * r); ++double gsl_ran_ugaussian_pdf (const double x); ++ ++double gsl_ran_gaussian_tail (const gsl_rng * r, const double a, const double sigma); ++double gsl_ran_gaussian_tail_pdf (const double x, const double a, const double sigma); ++ ++double gsl_ran_ugaussian_tail (const gsl_rng * r, const double a); ++double gsl_ran_ugaussian_tail_pdf (const double x, const double a); ++ ++void gsl_ran_bivariate_gaussian (const gsl_rng * r, double sigma_x, double sigma_y, double rho, double *x, double *y); ++double gsl_ran_bivariate_gaussian_pdf (const double x, const double y, const double sigma_x, const double sigma_y, const double rho); ++ ++double gsl_ran_landau (const gsl_rng * r); ++double gsl_ran_landau_pdf (const double x); ++ ++unsigned int gsl_ran_geometric (const gsl_rng * r, const double p); ++double gsl_ran_geometric_pdf (const unsigned int k, const double p); ++ ++unsigned int gsl_ran_hypergeometric (const gsl_rng * r, unsigned int n1, unsigned int n2, unsigned int t); ++double gsl_ran_hypergeometric_pdf (const unsigned int k, const unsigned int n1, const unsigned int n2, unsigned int t); ++ ++double gsl_ran_gumbel1 (const gsl_rng * r, const double a, const double b); ++double gsl_ran_gumbel1_pdf (const double x, const double a, const double b); ++ ++double gsl_ran_gumbel2 (const gsl_rng * r, const double a, const double b); ++double gsl_ran_gumbel2_pdf (const double x, const double a, const double b); ++ ++double gsl_ran_logistic (const gsl_rng * r, const double a); ++double gsl_ran_logistic_pdf (const double x, const double a); ++ ++double gsl_ran_lognormal (const gsl_rng * r, const double zeta, const double sigma); ++double gsl_ran_lognormal_pdf (const double x, const double zeta, const double sigma); ++ ++unsigned int gsl_ran_logarithmic (const gsl_rng * r, const double p); ++double gsl_ran_logarithmic_pdf (const unsigned int k, const double p); ++ ++void gsl_ran_multinomial (const gsl_rng * r, const size_t K, ++ const unsigned int N, const double p[], ++ unsigned int n[] ); ++double gsl_ran_multinomial_pdf (const size_t K, ++ const double p[], const unsigned int n[] ); ++double gsl_ran_multinomial_lnpdf (const size_t K, ++ const double p[], const unsigned int n[] ); ++ ++ ++unsigned int gsl_ran_negative_binomial (const gsl_rng * r, double p, double n); ++double gsl_ran_negative_binomial_pdf (const unsigned int k, const double p, double n); ++ ++unsigned int gsl_ran_pascal (const gsl_rng * r, double p, unsigned int n); ++double gsl_ran_pascal_pdf (const unsigned int k, const double p, unsigned int n); ++ ++double gsl_ran_pareto (const gsl_rng * r, double a, const double b); ++double gsl_ran_pareto_pdf (const double x, const double a, const double b); ++ ++unsigned int gsl_ran_poisson (const gsl_rng * r, double mu); ++void gsl_ran_poisson_array (const gsl_rng * r, size_t n, unsigned int array[], ++ double mu); ++double gsl_ran_poisson_pdf (const unsigned int k, const double mu); ++ ++double gsl_ran_rayleigh (const gsl_rng * r, const double sigma); ++double gsl_ran_rayleigh_pdf (const double x, const double sigma); ++ ++double gsl_ran_rayleigh_tail (const gsl_rng * r, const double a, const double sigma); ++double gsl_ran_rayleigh_tail_pdf (const double x, const double a, const double sigma); ++ ++double gsl_ran_tdist (const gsl_rng * r, const double nu); ++double gsl_ran_tdist_pdf (const double x, const double nu); ++ ++double gsl_ran_laplace (const gsl_rng * r, const double a); ++double gsl_ran_laplace_pdf (const double x, const double a); ++ ++double gsl_ran_levy (const gsl_rng * r, const double c, const double alpha); ++double gsl_ran_levy_skew (const gsl_rng * r, const double c, const double alpha, const double beta); ++ ++double gsl_ran_weibull (const gsl_rng * r, const double a, const double b); ++double gsl_ran_weibull_pdf (const double x, const double a, const double b); ++ ++void gsl_ran_dir_2d (const gsl_rng * r, double * x, double * y); ++void gsl_ran_dir_2d_trig_method (const gsl_rng * r, double * x, double * y); ++void gsl_ran_dir_3d (const gsl_rng * r, double * x, double * y, double * z); ++void gsl_ran_dir_nd (const gsl_rng * r, size_t n, double * x); ++ ++void gsl_ran_shuffle (const gsl_rng * r, void * base, size_t nmembm, size_t size); ++int gsl_ran_choose (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ; ++void gsl_ran_sample (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ; ++ ++ ++typedef struct { /* struct for Walker algorithm */ ++ size_t K; ++ size_t *A; ++ double *F; ++} gsl_ran_discrete_t; ++ ++gsl_ran_discrete_t * gsl_ran_discrete_preproc (size_t K, const double *P); ++void gsl_ran_discrete_free(gsl_ran_discrete_t *g); ++size_t gsl_ran_discrete (const gsl_rng *r, const gsl_ran_discrete_t *g); ++double gsl_ran_discrete_pdf (size_t k, const gsl_ran_discrete_t *g); ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_RANDIST_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h (revision 14078) +@@ -0,0 +1,162 @@ ++/* sum/gsl_sum.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++/* Author: G. Jungman */ ++ ++ ++#ifndef __GSL_SUM_H__ ++#define __GSL_SUM_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++/* Workspace for Levin U Transform with error estimation, ++ * ++ * size = number of terms the workspace can handle ++ * sum_plain = simple sum of series ++ * q_num = backward diagonal of numerator; length = size ++ * q_den = backward diagonal of denominator; length = size ++ * dq_num = table of numerator derivatives; length = size**2 ++ * dq_den = table of denominator derivatives; length = size**2 ++ * dsum = derivative of sum wrt term i; length = size ++ */ ++ ++typedef struct ++{ ++ size_t size; ++ size_t i; /* position in array */ ++ size_t terms_used; /* number of calls */ ++ double sum_plain; ++ double *q_num; ++ double *q_den; ++ double *dq_num; ++ double *dq_den; ++ double *dsum; ++} ++gsl_sum_levin_u_workspace; ++ ++gsl_sum_levin_u_workspace *gsl_sum_levin_u_alloc (size_t n); ++void gsl_sum_levin_u_free (gsl_sum_levin_u_workspace * w); ++ ++/* Basic Levin-u acceleration method. ++ * ++ * array = array of series elements ++ * n = size of array ++ * sum_accel = result of summation acceleration ++ * err = estimated error ++ * ++ * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602] ++ */ ++ ++int gsl_sum_levin_u_accel (const double *array, ++ const size_t n, ++ gsl_sum_levin_u_workspace * w, ++ double *sum_accel, double *abserr); ++ ++/* Basic Levin-u acceleration method with constraints on the terms ++ * used, ++ * ++ * array = array of series elements ++ * n = size of array ++ * min_terms = minimum number of terms to sum ++ * max_terms = maximum number of terms to sum ++ * sum_accel = result of summation acceleration ++ * err = estimated error ++ * ++ * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602] ++ */ ++ ++int gsl_sum_levin_u_minmax (const double *array, ++ const size_t n, ++ const size_t min_terms, ++ const size_t max_terms, ++ gsl_sum_levin_u_workspace * w, ++ double *sum_accel, double *abserr); ++ ++/* Basic Levin-u step w/o reference to the array of terms. ++ * We only need to specify the value of the current term ++ * to execute the step. See TOMS-745. ++ * ++ * sum = t0 + ... + t_{n-1} + term; term = t_{n} ++ * ++ * term = value of the series term to be added ++ * n = position of term in series (starting from 0) ++ * sum_accel = result of summation acceleration ++ * sum_plain = simple sum of series ++ */ ++ ++int ++gsl_sum_levin_u_step (const double term, ++ const size_t n, ++ const size_t nmax, ++ gsl_sum_levin_u_workspace * w, ++ double *sum_accel); ++ ++/* The following functions perform the same calculation without ++ estimating the errors. They require O(N) storage instead of O(N^2). ++ This may be useful for summing many similar series where the size ++ of the error has already been estimated reliably and is not ++ expected to change. */ ++ ++typedef struct ++{ ++ size_t size; ++ size_t i; /* position in array */ ++ size_t terms_used; /* number of calls */ ++ double sum_plain; ++ double *q_num; ++ double *q_den; ++ double *dsum; ++} ++gsl_sum_levin_utrunc_workspace; ++ ++gsl_sum_levin_utrunc_workspace *gsl_sum_levin_utrunc_alloc (size_t n); ++void gsl_sum_levin_utrunc_free (gsl_sum_levin_utrunc_workspace * w); ++ ++int gsl_sum_levin_utrunc_accel (const double *array, ++ const size_t n, ++ gsl_sum_levin_utrunc_workspace * w, ++ double *sum_accel, double *abserr_trunc); ++ ++int gsl_sum_levin_utrunc_minmax (const double *array, ++ const size_t n, ++ const size_t min_terms, ++ const size_t max_terms, ++ gsl_sum_levin_utrunc_workspace * w, ++ double *sum_accel, double *abserr_trunc); ++ ++int gsl_sum_levin_utrunc_step (const double term, ++ const size_t n, ++ gsl_sum_levin_utrunc_workspace * w, ++ double *sum_accel); ++ ++__END_DECLS ++ ++#endif /* __GSL_SUM_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h (revision 14078) +@@ -0,0 +1,50 @@ ++/* sort/gsl_sort_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SORT_LONG_H__ ++#define __GSL_SORT_LONG_H__ ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++void gsl_sort_long (long * data, const size_t stride, const size_t n); ++void gsl_sort_long_index (size_t * p, const long * data, const size_t stride, const size_t n); ++ ++int gsl_sort_long_smallest (long * dest, const size_t k, const long * src, const size_t stride, const size_t n); ++int gsl_sort_long_smallest_index (size_t * p, const size_t k, const long * src, const size_t stride, const size_t n); ++ ++int gsl_sort_long_largest (long * dest, const size_t k, const long * src, const size_t stride, const size_t n); ++int gsl_sort_long_largest_index (size_t * p, const size_t k, const long * src, const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_SORT_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h (revision 14078) +@@ -0,0 +1,111 @@ ++/* Author: G. Jungman + modifications from O. Teytaud ++ */ ++#ifndef __GSL_QRNG_H__ ++#define __GSL_QRNG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* Once again, more inane C-style OOP... kill me now. */ ++ ++/* Structure describing a type of generator. ++ */ ++typedef struct ++{ ++ const char * name; ++ unsigned int max_dimension; ++ size_t (*state_size) (unsigned int dimension); ++ int (*init_state) (void * state, unsigned int dimension); ++ int (*get) (void * state, unsigned int dimension, double x[]); ++} ++gsl_qrng_type; ++ ++/* Structure describing a generator instance of a ++ * specified type, with generator-specific state info ++ * and dimension-specific info. ++ */ ++typedef struct ++{ ++ const gsl_qrng_type * type; ++ unsigned int dimension; ++ size_t state_size; ++ void * state; ++} ++gsl_qrng; ++ ++ ++/* Supported generator types. ++ */ ++GSL_VAR const gsl_qrng_type * gsl_qrng_niederreiter_2; ++GSL_VAR const gsl_qrng_type * gsl_qrng_sobol; ++GSL_VAR const gsl_qrng_type * gsl_qrng_halton; ++GSL_VAR const gsl_qrng_type * gsl_qrng_reversehalton; ++ ++ ++/* Allocate and initialize a generator ++ * of the specified type, in the given ++ * space dimension. ++ */ ++gsl_qrng * gsl_qrng_alloc (const gsl_qrng_type * T, unsigned int dimension); ++ ++ ++/* Copy a generator. */ ++int gsl_qrng_memcpy (gsl_qrng * dest, const gsl_qrng * src); ++ ++ ++/* Clone a generator. */ ++gsl_qrng * gsl_qrng_clone (const gsl_qrng * q); ++ ++ ++/* Free a generator. */ ++void gsl_qrng_free (gsl_qrng * q); ++ ++ ++/* Intialize a generator. */ ++void gsl_qrng_init (gsl_qrng * q); ++ ++ ++/* Get the standardized name of the generator. */ ++const char * gsl_qrng_name (const gsl_qrng * q); ++ ++ ++/* ISN'T THIS CONFUSING FOR PEOPLE? ++ WHAT IF SOMEBODY TRIES TO COPY WITH THIS ??? ++ */ ++size_t gsl_qrng_size (const gsl_qrng * q); ++ ++ ++void * gsl_qrng_state (const gsl_qrng * q); ++ ++ ++/* Retrieve next vector in sequence. */ ++INLINE_DECL int gsl_qrng_get (const gsl_qrng * q, double x[]); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN int gsl_qrng_get (const gsl_qrng * q, double x[]) ++{ ++ return (q->type->get) (q->state, q->dimension, x); ++} ++ ++#endif /* HAVE_INLINE */ ++ ++ ++__END_DECLS ++ ++ ++#endif /* !__GSL_QRNG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h (revision 14078) +@@ -0,0 +1,45 @@ ++/* permutation/gsl_permute_vector_ulong.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_PERMUTE_VECTOR_ULONG_H__ ++#define __GSL_PERMUTE_VECTOR_ULONG_H__ ++ ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_permute_vector_ulong (const gsl_permutation * p, gsl_vector_ulong * v); ++int gsl_permute_vector_ulong_inverse (const gsl_permutation * p, gsl_vector_ulong * v); ++ ++__END_DECLS ++ ++#endif /* __GSL_PERMUTE_VECTOR_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h (revision 14078) +@@ -0,0 +1,52 @@ ++/* diff/gsl_diff.h ++ * ++ * Copyright (C) 2000 David Morrison ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_DIFF_H__ ++#define __GSL_DIFF_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++#ifndef GSL_DISABLE_DEPRECATED ++int gsl_diff_central (const gsl_function *f, ++ double x, ++ double *result, double *abserr); ++ ++int gsl_diff_backward (const gsl_function *f, ++ double x, ++ double *result, double *abserr); ++ ++int gsl_diff_forward (const gsl_function *f, ++ double x, ++ double *result, double *abserr); ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_DIFF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h (revision 14078) +@@ -0,0 +1,65 @@ ++/* block/gsl_block_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_BLOCK_LONG_H__ ++#define __GSL_BLOCK_LONG_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++struct gsl_block_long_struct ++{ ++ size_t size; ++ long *data; ++}; ++ ++typedef struct gsl_block_long_struct gsl_block_long; ++ ++gsl_block_long *gsl_block_long_alloc (const size_t n); ++gsl_block_long *gsl_block_long_calloc (const size_t n); ++void gsl_block_long_free (gsl_block_long * b); ++ ++int gsl_block_long_fread (FILE * stream, gsl_block_long * b); ++int gsl_block_long_fwrite (FILE * stream, const gsl_block_long * b); ++int gsl_block_long_fscanf (FILE * stream, gsl_block_long * b); ++int gsl_block_long_fprintf (FILE * stream, const gsl_block_long * b, const char *format); ++ ++int gsl_block_long_raw_fread (FILE * stream, long * b, const size_t n, const size_t stride); ++int gsl_block_long_raw_fwrite (FILE * stream, const long * b, const size_t n, const size_t stride); ++int gsl_block_long_raw_fscanf (FILE * stream, long * b, const size_t n, const size_t stride); ++int gsl_block_long_raw_fprintf (FILE * stream, const long * b, const size_t n, const size_t stride, const char *format); ++ ++size_t gsl_block_long_size (const gsl_block_long * b); ++long * gsl_block_long_data (const gsl_block_long * b); ++ ++__END_DECLS ++ ++#endif /* __GSL_BLOCK_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h (revision 14078) +@@ -0,0 +1,79 @@ ++/* statistics/gsl_statistics_uchar.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_STATISTICS_UCHAR_H__ ++#define __GSL_STATISTICS_UCHAR_H__ ++ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_stats_uchar_mean (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_variance (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_sd (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_variance_with_fixed_mean (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uchar_sd_with_fixed_mean (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uchar_tss (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_tss_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_uchar_absdev (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_skew (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_kurtosis (const unsigned char data[], const size_t stride, const size_t n); ++double gsl_stats_uchar_lag1_autocorrelation (const unsigned char data[], const size_t stride, const size_t n); ++ ++double gsl_stats_uchar_covariance (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n); ++double gsl_stats_uchar_correlation (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n); ++ ++double gsl_stats_uchar_variance_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uchar_sd_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uchar_absdev_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++double gsl_stats_uchar_skew_m_sd (const unsigned char data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_uchar_kurtosis_m_sd (const unsigned char data[], const size_t stride, const size_t n, const double mean, const double sd); ++double gsl_stats_uchar_lag1_autocorrelation_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); ++ ++double gsl_stats_uchar_covariance_m (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); ++ ++ ++double gsl_stats_uchar_pvariance (const unsigned char data1[], const size_t stride1, const size_t n1, const unsigned char data2[], const size_t stride2, const size_t n2); ++double gsl_stats_uchar_ttest (const unsigned char data1[], const size_t stride1, const size_t n1, const unsigned char data2[], const size_t stride2, const size_t n2); ++ ++unsigned char gsl_stats_uchar_max (const unsigned char data[], const size_t stride, const size_t n); ++unsigned char gsl_stats_uchar_min (const unsigned char data[], const size_t stride, const size_t n); ++void gsl_stats_uchar_minmax (unsigned char * min, unsigned char * max, const unsigned char data[], const size_t stride, const size_t n); ++ ++size_t gsl_stats_uchar_max_index (const unsigned char data[], const size_t stride, const size_t n); ++size_t gsl_stats_uchar_min_index (const unsigned char data[], const size_t stride, const size_t n); ++void gsl_stats_uchar_minmax_index (size_t * min_index, size_t * max_index, const unsigned char data[], const size_t stride, const size_t n); ++ ++double gsl_stats_uchar_median_from_sorted_data (const unsigned char sorted_data[], const size_t stride, const size_t n) ; ++double gsl_stats_uchar_quantile_from_sorted_data (const unsigned char sorted_data[], const size_t stride, const size_t n, const double f) ; ++ ++__END_DECLS ++ ++#endif /* __GSL_STATISTICS_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h (revision 14078) +@@ -0,0 +1,63 @@ ++/* sys/gsl_sys.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_SYS_H__ ++#define __GSL_SYS_H__ ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++double gsl_log1p (const double x); ++double gsl_expm1 (const double x); ++double gsl_hypot (const double x, const double y); ++double gsl_hypot3 (const double x, const double y, const double z); ++double gsl_acosh (const double x); ++double gsl_asinh (const double x); ++double gsl_atanh (const double x); ++ ++int gsl_isnan (const double x); ++int gsl_isinf (const double x); ++int gsl_finite (const double x); ++ ++double gsl_nan (void); ++double gsl_posinf (void); ++double gsl_neginf (void); ++double gsl_fdiv (const double x, const double y); ++ ++double gsl_coerce_double (const double x); ++float gsl_coerce_float (const float x); ++long double gsl_coerce_long_double (const long double x); ++ ++double gsl_ldexp(const double x, const int e); ++double gsl_frexp(const double x, int * e); ++ ++int gsl_fcmp (const double x1, const double x2, const double epsilon); ++ ++__END_DECLS ++ ++#endif /* __GSL_SYS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h (revision 14078) +@@ -0,0 +1,61 @@ ++/* gsl_pow_int.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_POW_INT_H__ ++#define __GSL_POW_INT_H__ ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++INLINE_DECL double gsl_pow_2(const double x); ++INLINE_DECL double gsl_pow_3(const double x); ++INLINE_DECL double gsl_pow_4(const double x); ++INLINE_DECL double gsl_pow_5(const double x); ++INLINE_DECL double gsl_pow_6(const double x); ++INLINE_DECL double gsl_pow_7(const double x); ++INLINE_DECL double gsl_pow_8(const double x); ++INLINE_DECL double gsl_pow_9(const double x); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN double gsl_pow_2(const double x) { return x*x; } ++INLINE_FUN double gsl_pow_3(const double x) { return x*x*x; } ++INLINE_FUN double gsl_pow_4(const double x) { double x2 = x*x; return x2*x2; } ++INLINE_FUN double gsl_pow_5(const double x) { double x2 = x*x; return x2*x2*x; } ++INLINE_FUN double gsl_pow_6(const double x) { double x2 = x*x; return x2*x2*x2; } ++INLINE_FUN double gsl_pow_7(const double x) { double x3 = x*x*x; return x3*x3*x; } ++INLINE_FUN double gsl_pow_8(const double x) { double x2 = x*x; double x4 = x2*x2; return x4*x4; } ++INLINE_FUN double gsl_pow_9(const double x) { double x3 = x*x*x; return x3*x3*x3; } ++#endif ++ ++double gsl_pow_int(double x, int n); ++double gsl_pow_uint(double x, unsigned int n); ++ ++__END_DECLS ++ ++#endif /* __GSL_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h (revision 14078) +@@ -0,0 +1,133 @@ ++/* cheb/gsl_chebyshev.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CHEBYSHEV_H__ ++#define __GSL_CHEBYSHEV_H__ ++ ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++ ++/* data for a Chebyshev series over a given interval */ ++ ++struct gsl_cheb_series_struct { ++ ++ double * c; /* coefficients */ ++ size_t order; /* order of expansion */ ++ double a; /* lower interval point */ ++ double b; /* upper interval point */ ++ ++ /* The following exists (mostly) for the benefit ++ * of the implementation. It is an effective single ++ * precision order, for use in single precision ++ * evaluation. Users can use it if they like, but ++ * only they know how to calculate it, since it is ++ * specific to the approximated function. By default, ++ * order_sp = order. ++ * It is used explicitly only by the gsl_cheb_eval_mode ++ * functions, which are not meant for casual use. ++ */ ++ size_t order_sp; ++ ++ /* Additional elements not used by specfunc */ ++ ++ double * f; /* function evaluated at chebyschev points */ ++}; ++typedef struct gsl_cheb_series_struct gsl_cheb_series; ++ ++ ++/* Calculate a Chebyshev series of specified order over ++ * a specified interval, for a given function. ++ * Return 0 on failure. ++ */ ++gsl_cheb_series * gsl_cheb_alloc(const size_t order); ++ ++/* Free a Chebyshev series previously calculated with gsl_cheb_alloc(). ++ */ ++void gsl_cheb_free(gsl_cheb_series * cs); ++ ++/* Calculate a Chebyshev series using the storage provided. ++ * Uses the interval (a,b) and the order with which it ++ * was initially created. ++ * ++ */ ++int gsl_cheb_init(gsl_cheb_series * cs, const gsl_function * func, ++ const double a, const double b); ++ ++/* Return the order, size of coefficient array and coefficient array ptr */ ++size_t gsl_cheb_order (const gsl_cheb_series * cs); ++size_t gsl_cheb_size (const gsl_cheb_series * cs); ++double *gsl_cheb_coeffs (const gsl_cheb_series * cs); ++ ++/* Evaluate a Chebyshev series at a given point. ++ * No errors can occur for a struct obtained from gsl_cheb_new(). ++ */ ++double gsl_cheb_eval(const gsl_cheb_series * cs, const double x); ++int gsl_cheb_eval_err(const gsl_cheb_series * cs, const double x, ++ double * result, double * abserr); ++ ++ ++/* Evaluate a Chebyshev series at a given point, to (at most) the given order. ++ * No errors can occur for a struct obtained from gsl_cheb_new(). ++ */ ++double gsl_cheb_eval_n(const gsl_cheb_series * cs, const size_t order, ++ const double x); ++int gsl_cheb_eval_n_err(const gsl_cheb_series * cs, const size_t order, ++ const double x, double * result, double * abserr); ++ ++ ++/* Evaluate a Chebyshev series at a given point, using the default ++ * order for double precision mode(s) and the single precision ++ * order for other modes. ++ * No errors can occur for a struct obtained from gsl_cheb_new(). ++ */ ++double gsl_cheb_eval_mode(const gsl_cheb_series * cs, const double x, gsl_mode_t mode); ++int gsl_cheb_eval_mode_e(const gsl_cheb_series * cs, const double x, gsl_mode_t mode, double * result, double * abserr); ++ ++ ++ ++/* Compute the derivative of a Chebyshev series. ++ */ ++int gsl_cheb_calc_deriv(gsl_cheb_series * deriv, const gsl_cheb_series * cs); ++ ++/* Compute the integral of a Chebyshev series. The ++ * integral is fixed by the condition that it equals zero at ++ * the left end-point, ie it is precisely ++ * Integrate[cs(t; a,b), {t, a, x}] ++ */ ++int gsl_cheb_calc_integ(gsl_cheb_series * integ, const gsl_cheb_series * cs); ++ ++ ++ ++ ++__END_DECLS ++ ++#endif /* __GSL_CHEBYSHEV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h (revision 14078) +@@ -0,0 +1,116 @@ ++/* const/gsl_const_cgs.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, ++ * 2006, 2007, 2008, 2009 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_CONST_CGS__ ++#define __GSL_CONST_CGS__ ++ ++#define GSL_CONST_CGS_SPEED_OF_LIGHT (2.99792458e10) /* cm / s */ ++#define GSL_CONST_CGS_GRAVITATIONAL_CONSTANT (6.673e-8) /* cm^3 / g s^2 */ ++#define GSL_CONST_CGS_PLANCKS_CONSTANT_H (6.62606896e-27) /* g cm^2 / s */ ++#define GSL_CONST_CGS_PLANCKS_CONSTANT_HBAR (1.05457162825e-27) /* g cm^2 / s */ ++#define GSL_CONST_CGS_ASTRONOMICAL_UNIT (1.49597870691e13) /* cm */ ++#define GSL_CONST_CGS_LIGHT_YEAR (9.46053620707e17) /* cm */ ++#define GSL_CONST_CGS_PARSEC (3.08567758135e18) /* cm */ ++#define GSL_CONST_CGS_GRAV_ACCEL (9.80665e2) /* cm / s^2 */ ++#define GSL_CONST_CGS_ELECTRON_VOLT (1.602176487e-12) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_MASS_ELECTRON (9.10938188e-28) /* g */ ++#define GSL_CONST_CGS_MASS_MUON (1.88353109e-25) /* g */ ++#define GSL_CONST_CGS_MASS_PROTON (1.67262158e-24) /* g */ ++#define GSL_CONST_CGS_MASS_NEUTRON (1.67492716e-24) /* g */ ++#define GSL_CONST_CGS_RYDBERG (2.17987196968e-11) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_BOLTZMANN (1.3806504e-16) /* g cm^2 / K s^2 */ ++#define GSL_CONST_CGS_MOLAR_GAS (8.314472e7) /* g cm^2 / K mol s^2 */ ++#define GSL_CONST_CGS_STANDARD_GAS_VOLUME (2.2710981e4) /* cm^3 / mol */ ++#define GSL_CONST_CGS_MINUTE (6e1) /* s */ ++#define GSL_CONST_CGS_HOUR (3.6e3) /* s */ ++#define GSL_CONST_CGS_DAY (8.64e4) /* s */ ++#define GSL_CONST_CGS_WEEK (6.048e5) /* s */ ++#define GSL_CONST_CGS_INCH (2.54e0) /* cm */ ++#define GSL_CONST_CGS_FOOT (3.048e1) /* cm */ ++#define GSL_CONST_CGS_YARD (9.144e1) /* cm */ ++#define GSL_CONST_CGS_MILE (1.609344e5) /* cm */ ++#define GSL_CONST_CGS_NAUTICAL_MILE (1.852e5) /* cm */ ++#define GSL_CONST_CGS_FATHOM (1.8288e2) /* cm */ ++#define GSL_CONST_CGS_MIL (2.54e-3) /* cm */ ++#define GSL_CONST_CGS_POINT (3.52777777778e-2) /* cm */ ++#define GSL_CONST_CGS_TEXPOINT (3.51459803515e-2) /* cm */ ++#define GSL_CONST_CGS_MICRON (1e-4) /* cm */ ++#define GSL_CONST_CGS_ANGSTROM (1e-8) /* cm */ ++#define GSL_CONST_CGS_HECTARE (1e8) /* cm^2 */ ++#define GSL_CONST_CGS_ACRE (4.04685642241e7) /* cm^2 */ ++#define GSL_CONST_CGS_BARN (1e-24) /* cm^2 */ ++#define GSL_CONST_CGS_LITER (1e3) /* cm^3 */ ++#define GSL_CONST_CGS_US_GALLON (3.78541178402e3) /* cm^3 */ ++#define GSL_CONST_CGS_QUART (9.46352946004e2) /* cm^3 */ ++#define GSL_CONST_CGS_PINT (4.73176473002e2) /* cm^3 */ ++#define GSL_CONST_CGS_CUP (2.36588236501e2) /* cm^3 */ ++#define GSL_CONST_CGS_FLUID_OUNCE (2.95735295626e1) /* cm^3 */ ++#define GSL_CONST_CGS_TABLESPOON (1.47867647813e1) /* cm^3 */ ++#define GSL_CONST_CGS_TEASPOON (4.92892159375e0) /* cm^3 */ ++#define GSL_CONST_CGS_CANADIAN_GALLON (4.54609e3) /* cm^3 */ ++#define GSL_CONST_CGS_UK_GALLON (4.546092e3) /* cm^3 */ ++#define GSL_CONST_CGS_MILES_PER_HOUR (4.4704e1) /* cm / s */ ++#define GSL_CONST_CGS_KILOMETERS_PER_HOUR (2.77777777778e1) /* cm / s */ ++#define GSL_CONST_CGS_KNOT (5.14444444444e1) /* cm / s */ ++#define GSL_CONST_CGS_POUND_MASS (4.5359237e2) /* g */ ++#define GSL_CONST_CGS_OUNCE_MASS (2.8349523125e1) /* g */ ++#define GSL_CONST_CGS_TON (9.0718474e5) /* g */ ++#define GSL_CONST_CGS_METRIC_TON (1e6) /* g */ ++#define GSL_CONST_CGS_UK_TON (1.0160469088e6) /* g */ ++#define GSL_CONST_CGS_TROY_OUNCE (3.1103475e1) /* g */ ++#define GSL_CONST_CGS_CARAT (2e-1) /* g */ ++#define GSL_CONST_CGS_UNIFIED_ATOMIC_MASS (1.660538782e-24) /* g */ ++#define GSL_CONST_CGS_GRAM_FORCE (9.80665e2) /* cm g / s^2 */ ++#define GSL_CONST_CGS_POUND_FORCE (4.44822161526e5) /* cm g / s^2 */ ++#define GSL_CONST_CGS_KILOPOUND_FORCE (4.44822161526e8) /* cm g / s^2 */ ++#define GSL_CONST_CGS_POUNDAL (1.38255e4) /* cm g / s^2 */ ++#define GSL_CONST_CGS_CALORIE (4.1868e7) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_BTU (1.05505585262e10) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_THERM (1.05506e15) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_HORSEPOWER (7.457e9) /* g cm^2 / s^3 */ ++#define GSL_CONST_CGS_BAR (1e6) /* g / cm s^2 */ ++#define GSL_CONST_CGS_STD_ATMOSPHERE (1.01325e6) /* g / cm s^2 */ ++#define GSL_CONST_CGS_TORR (1.33322368421e3) /* g / cm s^2 */ ++#define GSL_CONST_CGS_METER_OF_MERCURY (1.33322368421e6) /* g / cm s^2 */ ++#define GSL_CONST_CGS_INCH_OF_MERCURY (3.38638815789e4) /* g / cm s^2 */ ++#define GSL_CONST_CGS_INCH_OF_WATER (2.490889e3) /* g / cm s^2 */ ++#define GSL_CONST_CGS_PSI (6.89475729317e4) /* g / cm s^2 */ ++#define GSL_CONST_CGS_POISE (1e0) /* g / cm s */ ++#define GSL_CONST_CGS_STOKES (1e0) /* cm^2 / s */ ++#define GSL_CONST_CGS_STILB (1e0) /* cd / cm^2 */ ++#define GSL_CONST_CGS_LUMEN (1e0) /* cd sr */ ++#define GSL_CONST_CGS_LUX (1e-4) /* cd sr / cm^2 */ ++#define GSL_CONST_CGS_PHOT (1e0) /* cd sr / cm^2 */ ++#define GSL_CONST_CGS_FOOTCANDLE (1.076e-3) /* cd sr / cm^2 */ ++#define GSL_CONST_CGS_LAMBERT (1e0) /* cd sr / cm^2 */ ++#define GSL_CONST_CGS_FOOTLAMBERT (1.07639104e-3) /* cd sr / cm^2 */ ++#define GSL_CONST_CGS_CURIE (3.7e10) /* 1 / s */ ++#define GSL_CONST_CGS_ROENTGEN (2.58e-7) /* A s / g */ ++#define GSL_CONST_CGS_RAD (1e2) /* cm^2 / s^2 */ ++#define GSL_CONST_CGS_SOLAR_MASS (1.98892e33) /* g */ ++#define GSL_CONST_CGS_BOHR_RADIUS (5.291772083e-9) /* cm */ ++#define GSL_CONST_CGS_NEWTON (1e5) /* cm g / s^2 */ ++#define GSL_CONST_CGS_DYNE (1e0) /* cm g / s^2 */ ++#define GSL_CONST_CGS_JOULE (1e7) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_ERG (1e0) /* g cm^2 / s^2 */ ++#define GSL_CONST_CGS_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-5) /* g / K^4 s^3 */ ++#define GSL_CONST_CGS_THOMSON_CROSS_SECTION (6.65245893699e-25) /* cm^2 */ ++ ++#endif /* __GSL_CONST_CGS__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h (revision 14078) +@@ -0,0 +1,80 @@ ++/* fft/gsl_fft_real.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_FFT_REAL_H__ ++#define __GSL_FFT_REAL_H__ ++ ++#include ++ ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++int gsl_fft_real_radix2_transform (double data[], const size_t stride, const size_t n) ; ++ ++typedef struct ++ { ++ size_t n; ++ size_t nf; ++ size_t factor[64]; ++ gsl_complex *twiddle[64]; ++ gsl_complex *trig; ++ } ++gsl_fft_real_wavetable; ++ ++typedef struct ++ { ++ size_t n; ++ double *scratch; ++ } ++gsl_fft_real_workspace; ++ ++gsl_fft_real_wavetable * gsl_fft_real_wavetable_alloc (size_t n); ++ ++void gsl_fft_real_wavetable_free (gsl_fft_real_wavetable * wavetable); ++ ++gsl_fft_real_workspace * gsl_fft_real_workspace_alloc (size_t n); ++ ++void gsl_fft_real_workspace_free (gsl_fft_real_workspace * workspace); ++ ++ ++int gsl_fft_real_transform (double data[], const size_t stride, const size_t n, ++ const gsl_fft_real_wavetable * wavetable, ++ gsl_fft_real_workspace * work); ++ ++ ++int gsl_fft_real_unpack (const double real_coefficient[], ++ double complex_coefficient[], ++ const size_t stride, const size_t n); ++ ++__END_DECLS ++ ++#endif /* __GSL_FFT_REAL_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h (revision 14078) +@@ -0,0 +1,350 @@ ++/* matrix/gsl_matrix_long.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_MATRIX_LONG_H__ ++#define __GSL_MATRIX_LONG_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size1; ++ size_t size2; ++ size_t tda; ++ long * data; ++ gsl_block_long * block; ++ int owner; ++} gsl_matrix_long; ++ ++typedef struct ++{ ++ gsl_matrix_long matrix; ++} _gsl_matrix_long_view; ++ ++typedef _gsl_matrix_long_view gsl_matrix_long_view; ++ ++typedef struct ++{ ++ gsl_matrix_long matrix; ++} _gsl_matrix_long_const_view; ++ ++typedef const _gsl_matrix_long_const_view gsl_matrix_long_const_view; ++ ++/* Allocation */ ++ ++gsl_matrix_long * ++gsl_matrix_long_alloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_long * ++gsl_matrix_long_calloc (const size_t n1, const size_t n2); ++ ++gsl_matrix_long * ++gsl_matrix_long_alloc_from_block (gsl_block_long * b, ++ const size_t offset, ++ const size_t n1, ++ const size_t n2, ++ const size_t d2); ++ ++gsl_matrix_long * ++gsl_matrix_long_alloc_from_matrix (gsl_matrix_long * m, ++ const size_t k1, ++ const size_t k2, ++ const size_t n1, ++ const size_t n2); ++ ++gsl_vector_long * ++gsl_vector_long_alloc_row_from_matrix (gsl_matrix_long * m, ++ const size_t i); ++ ++gsl_vector_long * ++gsl_vector_long_alloc_col_from_matrix (gsl_matrix_long * m, ++ const size_t j); ++ ++void gsl_matrix_long_free (gsl_matrix_long * m); ++ ++/* Views */ ++ ++_gsl_matrix_long_view ++gsl_matrix_long_submatrix (gsl_matrix_long * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_long_view ++gsl_matrix_long_row (gsl_matrix_long * m, const size_t i); ++ ++_gsl_vector_long_view ++gsl_matrix_long_column (gsl_matrix_long * m, const size_t j); ++ ++_gsl_vector_long_view ++gsl_matrix_long_diagonal (gsl_matrix_long * m); ++ ++_gsl_vector_long_view ++gsl_matrix_long_subdiagonal (gsl_matrix_long * m, const size_t k); ++ ++_gsl_vector_long_view ++gsl_matrix_long_superdiagonal (gsl_matrix_long * m, const size_t k); ++ ++_gsl_vector_long_view ++gsl_matrix_long_subrow (gsl_matrix_long * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_long_view ++gsl_matrix_long_subcolumn (gsl_matrix_long * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_long_view ++gsl_matrix_long_view_array (long * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_view ++gsl_matrix_long_view_array_with_tda (long * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_long_view ++gsl_matrix_long_view_vector (gsl_vector_long * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_view ++gsl_matrix_long_view_vector_with_tda (gsl_vector_long * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++ ++_gsl_matrix_long_const_view ++gsl_matrix_long_const_submatrix (const gsl_matrix_long * m, ++ const size_t i, const size_t j, ++ const size_t n1, const size_t n2); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_row (const gsl_matrix_long * m, ++ const size_t i); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_column (const gsl_matrix_long * m, ++ const size_t j); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_diagonal (const gsl_matrix_long * m); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_subdiagonal (const gsl_matrix_long * m, ++ const size_t k); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_superdiagonal (const gsl_matrix_long * m, ++ const size_t k); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_subrow (const gsl_matrix_long * m, const size_t i, ++ const size_t offset, const size_t n); ++ ++_gsl_vector_long_const_view ++gsl_matrix_long_const_subcolumn (const gsl_matrix_long * m, const size_t j, ++ const size_t offset, const size_t n); ++ ++_gsl_matrix_long_const_view ++gsl_matrix_long_const_view_array (const long * base, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_const_view ++gsl_matrix_long_const_view_array_with_tda (const long * base, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++_gsl_matrix_long_const_view ++gsl_matrix_long_const_view_vector (const gsl_vector_long * v, ++ const size_t n1, ++ const size_t n2); ++ ++_gsl_matrix_long_const_view ++gsl_matrix_long_const_view_vector_with_tda (const gsl_vector_long * v, ++ const size_t n1, ++ const size_t n2, ++ const size_t tda); ++ ++/* Operations */ ++ ++void gsl_matrix_long_set_zero (gsl_matrix_long * m); ++void gsl_matrix_long_set_identity (gsl_matrix_long * m); ++void gsl_matrix_long_set_all (gsl_matrix_long * m, long x); ++ ++int gsl_matrix_long_fread (FILE * stream, gsl_matrix_long * m) ; ++int gsl_matrix_long_fwrite (FILE * stream, const gsl_matrix_long * m) ; ++int gsl_matrix_long_fscanf (FILE * stream, gsl_matrix_long * m); ++int gsl_matrix_long_fprintf (FILE * stream, const gsl_matrix_long * m, const char * format); ++ ++int gsl_matrix_long_memcpy(gsl_matrix_long * dest, const gsl_matrix_long * src); ++int gsl_matrix_long_swap(gsl_matrix_long * m1, gsl_matrix_long * m2); ++ ++int gsl_matrix_long_swap_rows(gsl_matrix_long * m, const size_t i, const size_t j); ++int gsl_matrix_long_swap_columns(gsl_matrix_long * m, const size_t i, const size_t j); ++int gsl_matrix_long_swap_rowcol(gsl_matrix_long * m, const size_t i, const size_t j); ++int gsl_matrix_long_transpose (gsl_matrix_long * m); ++int gsl_matrix_long_transpose_memcpy (gsl_matrix_long * dest, const gsl_matrix_long * src); ++ ++long gsl_matrix_long_max (const gsl_matrix_long * m); ++long gsl_matrix_long_min (const gsl_matrix_long * m); ++void gsl_matrix_long_minmax (const gsl_matrix_long * m, long * min_out, long * max_out); ++ ++void gsl_matrix_long_max_index (const gsl_matrix_long * m, size_t * imax, size_t *jmax); ++void gsl_matrix_long_min_index (const gsl_matrix_long * m, size_t * imin, size_t *jmin); ++void gsl_matrix_long_minmax_index (const gsl_matrix_long * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); ++ ++int gsl_matrix_long_equal (const gsl_matrix_long * a, const gsl_matrix_long * b); ++ ++int gsl_matrix_long_isnull (const gsl_matrix_long * m); ++int gsl_matrix_long_ispos (const gsl_matrix_long * m); ++int gsl_matrix_long_isneg (const gsl_matrix_long * m); ++int gsl_matrix_long_isnonneg (const gsl_matrix_long * m); ++ ++int gsl_matrix_long_add (gsl_matrix_long * a, const gsl_matrix_long * b); ++int gsl_matrix_long_sub (gsl_matrix_long * a, const gsl_matrix_long * b); ++int gsl_matrix_long_mul_elements (gsl_matrix_long * a, const gsl_matrix_long * b); ++int gsl_matrix_long_div_elements (gsl_matrix_long * a, const gsl_matrix_long * b); ++int gsl_matrix_long_scale (gsl_matrix_long * a, const double x); ++int gsl_matrix_long_add_constant (gsl_matrix_long * a, const double x); ++int gsl_matrix_long_add_diagonal (gsl_matrix_long * a, const double x); ++ ++/***********************************************************************/ ++/* The functions below are obsolete */ ++/***********************************************************************/ ++int gsl_matrix_long_get_row(gsl_vector_long * v, const gsl_matrix_long * m, const size_t i); ++int gsl_matrix_long_get_col(gsl_vector_long * v, const gsl_matrix_long * m, const size_t j); ++int gsl_matrix_long_set_row(gsl_matrix_long * m, const size_t i, const gsl_vector_long * v); ++int gsl_matrix_long_set_col(gsl_matrix_long * m, const size_t j, const gsl_vector_long * v); ++/***********************************************************************/ ++ ++/* inline functions if you are using GCC */ ++ ++INLINE_DECL long gsl_matrix_long_get(const gsl_matrix_long * m, const size_t i, const size_t j); ++INLINE_DECL void gsl_matrix_long_set(gsl_matrix_long * m, const size_t i, const size_t j, const long x); ++INLINE_DECL long * gsl_matrix_long_ptr(gsl_matrix_long * m, const size_t i, const size_t j); ++INLINE_DECL const long * gsl_matrix_long_const_ptr(const gsl_matrix_long * m, const size_t i, const size_t j); ++ ++#ifdef HAVE_INLINE ++INLINE_FUN ++long ++gsl_matrix_long_get(const gsl_matrix_long * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; ++ } ++ } ++#endif ++ return m->data[i * m->tda + j] ; ++} ++ ++INLINE_FUN ++void ++gsl_matrix_long_set(gsl_matrix_long * m, const size_t i, const size_t j, const long x) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ m->data[i * m->tda + j] = x ; ++} ++ ++INLINE_FUN ++long * ++gsl_matrix_long_ptr(gsl_matrix_long * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (long *) (m->data + (i * m->tda + j)) ; ++} ++ ++INLINE_FUN ++const long * ++gsl_matrix_long_const_ptr(const gsl_matrix_long * m, const size_t i, const size_t j) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(1)) ++ { ++ if (i >= m->size1) ++ { ++ GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; ++ } ++ else if (j >= m->size2) ++ { ++ GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; ++ } ++ } ++#endif ++ return (const long *) (m->data + (i * m->tda + j)) ; ++} ++ ++#endif ++ ++__END_DECLS ++ ++#endif /* __GSL_MATRIX_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h (revision 14078) +@@ -0,0 +1,251 @@ ++/* vector/gsl_vector_complex_double.h ++ * ++ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 3 of the License, or (at ++ * your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef __GSL_VECTOR_COMPLEX_DOUBLE_H__ ++#define __GSL_VECTOR_COMPLEX_DOUBLE_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#undef __BEGIN_DECLS ++#undef __END_DECLS ++#ifdef __cplusplus ++# define __BEGIN_DECLS extern "C" { ++# define __END_DECLS } ++#else ++# define __BEGIN_DECLS /* empty */ ++# define __END_DECLS /* empty */ ++#endif ++ ++__BEGIN_DECLS ++ ++typedef struct ++{ ++ size_t size; ++ size_t stride; ++ double *data; ++ gsl_block_complex *block; ++ int owner; ++} gsl_vector_complex; ++ ++typedef struct ++{ ++ gsl_vector_complex vector; ++} _gsl_vector_complex_view; ++ ++typedef _gsl_vector_complex_view gsl_vector_complex_view; ++ ++typedef struct ++{ ++ gsl_vector_complex vector; ++} _gsl_vector_complex_const_view; ++ ++typedef const _gsl_vector_complex_const_view gsl_vector_complex_const_view; ++ ++/* Allocation */ ++ ++gsl_vector_complex *gsl_vector_complex_alloc (const size_t n); ++gsl_vector_complex *gsl_vector_complex_calloc (const size_t n); ++ ++gsl_vector_complex * ++gsl_vector_complex_alloc_from_block (gsl_block_complex * b, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++gsl_vector_complex * ++gsl_vector_complex_alloc_from_vector (gsl_vector_complex * v, ++ const size_t offset, ++ const size_t n, ++ const size_t stride); ++ ++void gsl_vector_complex_free (gsl_vector_complex * v); ++ ++/* Views */ ++ ++_gsl_vector_complex_view ++gsl_vector_complex_view_array (double *base, ++ size_t n); ++ ++_gsl_vector_complex_view ++gsl_vector_complex_view_array_with_stride (double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_const_view ++gsl_vector_complex_const_view_array (const double *base, ++ size_t n); ++ ++_gsl_vector_complex_const_view ++gsl_vector_complex_const_view_array_with_stride (const double *base, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_view ++gsl_vector_complex_subvector (gsl_vector_complex *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_view ++gsl_vector_complex_subvector_with_stride (gsl_vector_complex *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_complex_const_view ++gsl_vector_complex_const_subvector (const gsl_vector_complex *base, ++ size_t i, ++ size_t n); ++ ++ ++_gsl_vector_complex_const_view ++gsl_vector_complex_const_subvector_with_stride (const gsl_vector_complex *v, ++ size_t i, ++ size_t stride, ++ size_t n); ++ ++_gsl_vector_view ++gsl_vector_complex_real (gsl_vector_complex *v); ++ ++_gsl_vector_view ++gsl_vector_complex_imag (gsl_vector_complex *v); ++ ++_gsl_vector_const_view ++gsl_vector_complex_const_real (const gsl_vector_complex *v); ++ ++_gsl_vector_const_view ++gsl_vector_complex_const_imag (const gsl_vector_complex *v); ++ ++ ++/* Operations */ ++ ++void gsl_vector_complex_set_zero (gsl_vector_complex * v); ++void gsl_vector_complex_set_all (gsl_vector_complex * v, ++ gsl_complex z); ++int gsl_vector_complex_set_basis (gsl_vector_complex * v, size_t i); ++ ++int gsl_vector_complex_fread (FILE * stream, ++ gsl_vector_complex * v); ++int gsl_vector_complex_fwrite (FILE * stream, ++ const gsl_vector_complex * v); ++int gsl_vector_complex_fscanf (FILE * stream, ++ gsl_vector_complex * v); ++int gsl_vector_complex_fprintf (FILE * stream, ++ const gsl_vector_complex * v, ++ const char *format); ++ ++int gsl_vector_complex_memcpy (gsl_vector_complex * dest, const gsl_vector_complex * src); ++ ++int gsl_vector_complex_reverse (gsl_vector_complex * v); ++ ++int gsl_vector_complex_swap (gsl_vector_complex * v, gsl_vector_complex * w); ++int gsl_vector_complex_swap_elements (gsl_vector_complex * v, const size_t i, const size_t j); ++ ++int gsl_vector_complex_equal (const gsl_vector_complex * u, ++ const gsl_vector_complex * v); ++ ++int gsl_vector_complex_isnull (const gsl_vector_complex * v); ++int gsl_vector_complex_ispos (const gsl_vector_complex * v); ++int gsl_vector_complex_isneg (const gsl_vector_complex * v); ++int gsl_vector_complex_isnonneg (const gsl_vector_complex * v); ++ ++int gsl_vector_complex_add (gsl_vector_complex * a, const gsl_vector_complex * b); ++int gsl_vector_complex_sub (gsl_vector_complex * a, const gsl_vector_complex * b); ++int gsl_vector_complex_mul (gsl_vector_complex * a, const gsl_vector_complex * b); ++int gsl_vector_complex_div (gsl_vector_complex * a, const gsl_vector_complex * b); ++int gsl_vector_complex_scale (gsl_vector_complex * a, const gsl_complex x); ++int gsl_vector_complex_add_constant (gsl_vector_complex * a, const gsl_complex x); ++ ++INLINE_DECL gsl_complex gsl_vector_complex_get (const gsl_vector_complex * v, const size_t i); ++INLINE_DECL void gsl_vector_complex_set (gsl_vector_complex * v, const size_t i, gsl_complex z); ++INLINE_DECL gsl_complex *gsl_vector_complex_ptr (gsl_vector_complex * v, const size_t i); ++INLINE_DECL const gsl_complex *gsl_vector_complex_const_ptr (const gsl_vector_complex * v, const size_t i); ++ ++#ifdef HAVE_INLINE ++ ++INLINE_FUN ++gsl_complex ++gsl_vector_complex_get (const gsl_vector_complex * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ gsl_complex zero = {{0, 0}}; ++ GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); ++ } ++#endif ++ return *GSL_COMPLEX_AT (v, i); ++} ++ ++INLINE_FUN ++void ++gsl_vector_complex_set (gsl_vector_complex * v, ++ const size_t i, gsl_complex z) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_VOID ("index out of range", GSL_EINVAL); ++ } ++#endif ++ *GSL_COMPLEX_AT (v, i) = z; ++} ++ ++INLINE_FUN ++gsl_complex * ++gsl_vector_complex_ptr (gsl_vector_complex * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_AT (v, i); ++} ++ ++INLINE_FUN ++const gsl_complex * ++gsl_vector_complex_const_ptr (const gsl_vector_complex * v, ++ const size_t i) ++{ ++#if GSL_RANGE_CHECK ++ if (GSL_RANGE_COND(i >= v->size)) ++ { ++ GSL_ERROR_NULL ("index out of range", GSL_EINVAL); ++ } ++#endif ++ return GSL_COMPLEX_AT (v, i); ++} ++ ++ ++#endif /* HAVE_INLINE */ ++ ++__END_DECLS ++ ++#endif /* __GSL_VECTOR_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk (revision 0) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk (revision 14078) +@@ -0,0 +1,16 @@ ++LOCAL_PATH:= $(call my-dir) ++include $(CLEAR_VARS) ++LOCAL_MODULE := libgsl ++LOCAL_SRC_FILES := libsgsl.a ++LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include/gsl ++include $(PREBUILT_STATIC_LIBRARY) ++ ++#include $(CLEAR_VARS) ++#LOCAL_MODULE := libgslcblas ++#LOCAL_SRC_FILES := libgslcblas.so.0 ++#include $(PREBUILT_SHARED_LIBRARY) ++ ++include $(CLEAR_VARS) ++LOCAL_MODULE := libgslcblas ++LOCAL_SRC_FILES := libsgslcblas.a ++include $(PREBUILT_STATIC_LIBRARY) +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgsl.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgsl.a +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgsl.a (revision 14077) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgsl.a (revision 14078) + +Property changes on: ../trunk-jpl/src/android/ISSM/jni/gsllib/libsgsl.a +___________________________________________________________________ +Added: svn:mime-type +## -0,0 +1 ## ++application/octet-stream Index: /issm/oecreview/Archive/14064-14311/ISSM-14078-14079.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14078-14079.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14078-14079.diff (revision 14312) @@ -0,0 +1,27649 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uchar.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_UCHAR_H__ +-#define __GSL_MATRIX_UCHAR_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- unsigned char * data; +- gsl_block_uchar * block; +- int owner; +-} gsl_matrix_uchar; +- +-typedef struct +-{ +- gsl_matrix_uchar matrix; +-} _gsl_matrix_uchar_view; +- +-typedef _gsl_matrix_uchar_view gsl_matrix_uchar_view; +- +-typedef struct +-{ +- gsl_matrix_uchar matrix; +-} _gsl_matrix_uchar_const_view; +- +-typedef const _gsl_matrix_uchar_const_view gsl_matrix_uchar_const_view; +- +-/* Allocation */ +- +-gsl_matrix_uchar * +-gsl_matrix_uchar_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_uchar * +-gsl_matrix_uchar_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_uchar * +-gsl_matrix_uchar_alloc_from_block (gsl_block_uchar * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_uchar * +-gsl_matrix_uchar_alloc_from_matrix (gsl_matrix_uchar * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_uchar * +-gsl_vector_uchar_alloc_row_from_matrix (gsl_matrix_uchar * m, +- const size_t i); +- +-gsl_vector_uchar * +-gsl_vector_uchar_alloc_col_from_matrix (gsl_matrix_uchar * m, +- const size_t j); +- +-void gsl_matrix_uchar_free (gsl_matrix_uchar * m); +- +-/* Views */ +- +-_gsl_matrix_uchar_view +-gsl_matrix_uchar_submatrix (gsl_matrix_uchar * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_row (gsl_matrix_uchar * m, const size_t i); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_column (gsl_matrix_uchar * m, const size_t j); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_diagonal (gsl_matrix_uchar * m); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_subdiagonal (gsl_matrix_uchar * m, const size_t k); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_superdiagonal (gsl_matrix_uchar * m, const size_t k); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_subrow (gsl_matrix_uchar * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_uchar_view +-gsl_matrix_uchar_subcolumn (gsl_matrix_uchar * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_uchar_view +-gsl_matrix_uchar_view_array (unsigned char * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uchar_view +-gsl_matrix_uchar_view_array_with_tda (unsigned char * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_uchar_view +-gsl_matrix_uchar_view_vector (gsl_vector_uchar * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uchar_view +-gsl_matrix_uchar_view_vector_with_tda (gsl_vector_uchar * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_uchar_const_view +-gsl_matrix_uchar_const_submatrix (const gsl_matrix_uchar * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_row (const gsl_matrix_uchar * m, +- const size_t i); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_column (const gsl_matrix_uchar * m, +- const size_t j); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_diagonal (const gsl_matrix_uchar * m); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_subdiagonal (const gsl_matrix_uchar * m, +- const size_t k); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_superdiagonal (const gsl_matrix_uchar * m, +- const size_t k); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_subrow (const gsl_matrix_uchar * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_uchar_const_view +-gsl_matrix_uchar_const_subcolumn (const gsl_matrix_uchar * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_uchar_const_view +-gsl_matrix_uchar_const_view_array (const unsigned char * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uchar_const_view +-gsl_matrix_uchar_const_view_array_with_tda (const unsigned char * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_uchar_const_view +-gsl_matrix_uchar_const_view_vector (const gsl_vector_uchar * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uchar_const_view +-gsl_matrix_uchar_const_view_vector_with_tda (const gsl_vector_uchar * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_uchar_set_zero (gsl_matrix_uchar * m); +-void gsl_matrix_uchar_set_identity (gsl_matrix_uchar * m); +-void gsl_matrix_uchar_set_all (gsl_matrix_uchar * m, unsigned char x); +- +-int gsl_matrix_uchar_fread (FILE * stream, gsl_matrix_uchar * m) ; +-int gsl_matrix_uchar_fwrite (FILE * stream, const gsl_matrix_uchar * m) ; +-int gsl_matrix_uchar_fscanf (FILE * stream, gsl_matrix_uchar * m); +-int gsl_matrix_uchar_fprintf (FILE * stream, const gsl_matrix_uchar * m, const char * format); +- +-int gsl_matrix_uchar_memcpy(gsl_matrix_uchar * dest, const gsl_matrix_uchar * src); +-int gsl_matrix_uchar_swap(gsl_matrix_uchar * m1, gsl_matrix_uchar * m2); +- +-int gsl_matrix_uchar_swap_rows(gsl_matrix_uchar * m, const size_t i, const size_t j); +-int gsl_matrix_uchar_swap_columns(gsl_matrix_uchar * m, const size_t i, const size_t j); +-int gsl_matrix_uchar_swap_rowcol(gsl_matrix_uchar * m, const size_t i, const size_t j); +-int gsl_matrix_uchar_transpose (gsl_matrix_uchar * m); +-int gsl_matrix_uchar_transpose_memcpy (gsl_matrix_uchar * dest, const gsl_matrix_uchar * src); +- +-unsigned char gsl_matrix_uchar_max (const gsl_matrix_uchar * m); +-unsigned char gsl_matrix_uchar_min (const gsl_matrix_uchar * m); +-void gsl_matrix_uchar_minmax (const gsl_matrix_uchar * m, unsigned char * min_out, unsigned char * max_out); +- +-void gsl_matrix_uchar_max_index (const gsl_matrix_uchar * m, size_t * imax, size_t *jmax); +-void gsl_matrix_uchar_min_index (const gsl_matrix_uchar * m, size_t * imin, size_t *jmin); +-void gsl_matrix_uchar_minmax_index (const gsl_matrix_uchar * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_uchar_equal (const gsl_matrix_uchar * a, const gsl_matrix_uchar * b); +- +-int gsl_matrix_uchar_isnull (const gsl_matrix_uchar * m); +-int gsl_matrix_uchar_ispos (const gsl_matrix_uchar * m); +-int gsl_matrix_uchar_isneg (const gsl_matrix_uchar * m); +-int gsl_matrix_uchar_isnonneg (const gsl_matrix_uchar * m); +- +-int gsl_matrix_uchar_add (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); +-int gsl_matrix_uchar_sub (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); +-int gsl_matrix_uchar_mul_elements (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); +-int gsl_matrix_uchar_div_elements (gsl_matrix_uchar * a, const gsl_matrix_uchar * b); +-int gsl_matrix_uchar_scale (gsl_matrix_uchar * a, const double x); +-int gsl_matrix_uchar_add_constant (gsl_matrix_uchar * a, const double x); +-int gsl_matrix_uchar_add_diagonal (gsl_matrix_uchar * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_uchar_get_row(gsl_vector_uchar * v, const gsl_matrix_uchar * m, const size_t i); +-int gsl_matrix_uchar_get_col(gsl_vector_uchar * v, const gsl_matrix_uchar * m, const size_t j); +-int gsl_matrix_uchar_set_row(gsl_matrix_uchar * m, const size_t i, const gsl_vector_uchar * v); +-int gsl_matrix_uchar_set_col(gsl_matrix_uchar * m, const size_t j, const gsl_vector_uchar * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL unsigned char gsl_matrix_uchar_get(const gsl_matrix_uchar * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_uchar_set(gsl_matrix_uchar * m, const size_t i, const size_t j, const unsigned char x); +-INLINE_DECL unsigned char * gsl_matrix_uchar_ptr(gsl_matrix_uchar * m, const size_t i, const size_t j); +-INLINE_DECL const unsigned char * gsl_matrix_uchar_const_ptr(const gsl_matrix_uchar * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-unsigned char +-gsl_matrix_uchar_get(const gsl_matrix_uchar * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_uchar_set(gsl_matrix_uchar * m, const size_t i, const size_t j, const unsigned char x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-unsigned char * +-gsl_matrix_uchar_ptr(gsl_matrix_uchar * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (unsigned char *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const unsigned char * +-gsl_matrix_uchar_const_ptr(const gsl_matrix_uchar * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const unsigned char *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_float.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_FLOAT_H__ +-#define __GSL_PERMUTE_VECTOR_FLOAT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_float (const gsl_permutation * p, gsl_vector_float * v); +-int gsl_permute_vector_float_inverse (const gsl_permutation * p, gsl_vector_float * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_long_double.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_complex_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ +-#define __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_complex_long_double_struct +-{ +- size_t size; +- long double *data; +-}; +- +-typedef struct gsl_block_complex_long_double_struct gsl_block_complex_long_double; +- +-gsl_block_complex_long_double *gsl_block_complex_long_double_alloc (const size_t n); +-gsl_block_complex_long_double *gsl_block_complex_long_double_calloc (const size_t n); +-void gsl_block_complex_long_double_free (gsl_block_complex_long_double * b); +- +-int gsl_block_complex_long_double_fread (FILE * stream, gsl_block_complex_long_double * b); +-int gsl_block_complex_long_double_fwrite (FILE * stream, const gsl_block_complex_long_double * b); +-int gsl_block_complex_long_double_fscanf (FILE * stream, gsl_block_complex_long_double * b); +-int gsl_block_complex_long_double_fprintf (FILE * stream, const gsl_block_complex_long_double * b, const char *format); +- +-int gsl_block_complex_long_double_raw_fread (FILE * stream, long double * b, const size_t n, const size_t stride); +-int gsl_block_complex_long_double_raw_fwrite (FILE * stream, const long double * b, const size_t n, const size_t stride); +-int gsl_block_complex_long_double_raw_fscanf (FILE * stream, long double * b, const size_t n, const size_t stride); +-int gsl_block_complex_long_double_raw_fprintf (FILE * stream, const long double * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_complex_long_double_size (const gsl_block_complex_long_double * b); +-long double * gsl_block_complex_long_double_data (const gsl_block_complex_long_double * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_int.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_INT_H__ +-#define __GSL_PERMUTE_INT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_int (const size_t * p, int * data, const size_t stride, const size_t n); +-int gsl_permute_int_inverse (const size_t * p, int * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gegenbauer.h (revision 14079) +@@ -1,73 +0,0 @@ +-/* specfunc/gsl_sf_gegenbauer.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_GEGENBAUER_H__ +-#define __GSL_SF_GEGENBAUER_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Evaluate Gegenbauer polynomials +- * using explicit representations. +- * +- * exceptions: none +- */ +-int gsl_sf_gegenpoly_1_e(double lambda, double x, gsl_sf_result * result); +-int gsl_sf_gegenpoly_2_e(double lambda, double x, gsl_sf_result * result); +-int gsl_sf_gegenpoly_3_e(double lambda, double x, gsl_sf_result * result); +-double gsl_sf_gegenpoly_1(double lambda, double x); +-double gsl_sf_gegenpoly_2(double lambda, double x); +-double gsl_sf_gegenpoly_3(double lambda, double x); +- +- +-/* Evaluate Gegenbauer polynomials. +- * +- * lambda > -1/2, n >= 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gegenpoly_n_e(int n, double lambda, double x, gsl_sf_result * result); +-double gsl_sf_gegenpoly_n(int n, double lambda, double x); +- +- +-/* Calculate array of Gegenbauer polynomials +- * for n = (0, 1, 2, ... nmax) +- * +- * lambda > -1/2, nmax >= 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gegenpoly_array(int nmax, double lambda, double x, double * result_array); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_GEGENBAUER_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_airy.h (revision 14079) +@@ -1,139 +0,0 @@ +-/* specfunc/gsl_sf_airy.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_AIRY_H__ +-#define __GSL_SF_AIRY_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Airy function Ai(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_airy_Ai_e(const double x, const gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Ai(const double x, gsl_mode_t mode); +- +- +-/* Airy function Bi(x) +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_airy_Bi_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Bi(const double x, gsl_mode_t mode); +- +- +-/* scaled Ai(x): +- * Ai(x) x < 0 +- * exp(+2/3 x^{3/2}) Ai(x) x > 0 +- * +- * exceptions: none +- */ +-int gsl_sf_airy_Ai_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Ai_scaled(const double x, gsl_mode_t mode); +- +- +-/* scaled Bi(x): +- * Bi(x) x < 0 +- * exp(-2/3 x^{3/2}) Bi(x) x > 0 +- * +- * exceptions: none +- */ +-int gsl_sf_airy_Bi_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Bi_scaled(const double x, gsl_mode_t mode); +- +- +-/* derivative Ai'(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_airy_Ai_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Ai_deriv(const double x, gsl_mode_t mode); +- +- +-/* derivative Bi'(x) +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_airy_Bi_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Bi_deriv(const double x, gsl_mode_t mode); +- +- +-/* scaled derivative Ai'(x): +- * Ai'(x) x < 0 +- * exp(+2/3 x^{3/2}) Ai'(x) x > 0 +- * +- * exceptions: none +- */ +-int gsl_sf_airy_Ai_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Ai_deriv_scaled(const double x, gsl_mode_t mode); +- +- +-/* scaled derivative: +- * Bi'(x) x < 0 +- * exp(-2/3 x^{3/2}) Bi'(x) x > 0 +- * +- * exceptions: none +- */ +-int gsl_sf_airy_Bi_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_airy_Bi_deriv_scaled(const double x, gsl_mode_t mode); +- +- +-/* Zeros of Ai(x) +- */ +-int gsl_sf_airy_zero_Ai_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_airy_zero_Ai(unsigned int s); +- +- +-/* Zeros of Bi(x) +- */ +-int gsl_sf_airy_zero_Bi_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_airy_zero_Bi(unsigned int s); +- +- +-/* Zeros of Ai'(x) +- */ +-int gsl_sf_airy_zero_Ai_deriv_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_airy_zero_Ai_deriv(unsigned int s); +- +- +-/* Zeros of Bi'(x) +- */ +-int gsl_sf_airy_zero_Bi_deriv_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_airy_zero_Bi_deriv(unsigned int s); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_AIRY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ulong.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_ULONG_H__ +-#define __GSL_BLOCK_ULONG_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_ulong_struct +-{ +- size_t size; +- unsigned long *data; +-}; +- +-typedef struct gsl_block_ulong_struct gsl_block_ulong; +- +-gsl_block_ulong *gsl_block_ulong_alloc (const size_t n); +-gsl_block_ulong *gsl_block_ulong_calloc (const size_t n); +-void gsl_block_ulong_free (gsl_block_ulong * b); +- +-int gsl_block_ulong_fread (FILE * stream, gsl_block_ulong * b); +-int gsl_block_ulong_fwrite (FILE * stream, const gsl_block_ulong * b); +-int gsl_block_ulong_fscanf (FILE * stream, gsl_block_ulong * b); +-int gsl_block_ulong_fprintf (FILE * stream, const gsl_block_ulong * b, const char *format); +- +-int gsl_block_ulong_raw_fread (FILE * stream, unsigned long * b, const size_t n, const size_t stride); +-int gsl_block_ulong_raw_fwrite (FILE * stream, const unsigned long * b, const size_t n, const size_t stride); +-int gsl_block_ulong_raw_fscanf (FILE * stream, unsigned long * b, const size_t n, const size_t stride); +-int gsl_block_ulong_raw_fprintf (FILE * stream, const unsigned long * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_ulong_size (const gsl_block_ulong * b); +-unsigned long * gsl_block_ulong_data (const gsl_block_ulong * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uchar.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_UCHAR_H__ +-#define __GSL_PERMUTE_UCHAR_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_uchar (const size_t * p, unsigned char * data, const size_t stride, const size_t n); +-int gsl_permute_uchar_inverse (const size_t * p, unsigned char * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_linalg.h (revision 14079) +@@ -1,592 +0,0 @@ +-/* linalg/gsl_linalg.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2006, 2007 Gerard Jungman, Brian Gough, Patrick Alken +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_LINALG_H__ +-#define __GSL_LINALG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-#define __BEGIN_DECLS extern "C" { +-#define __END_DECLS } +-#else +-#define __BEGIN_DECLS /* empty */ +-#define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef enum +- { +- GSL_LINALG_MOD_NONE = 0, +- GSL_LINALG_MOD_TRANSPOSE = 1, +- GSL_LINALG_MOD_CONJUGATE = 2 +- } +-gsl_linalg_matrix_mod_t; +- +- +-/* Note: You can now use the gsl_blas_dgemm function instead of matmult */ +- +-/* Simple implementation of matrix multiply. +- * Calculates C = A.B +- * +- * exceptions: GSL_EBADLEN +- */ +-int gsl_linalg_matmult (const gsl_matrix * A, +- const gsl_matrix * B, +- gsl_matrix * C); +- +- +-/* Simple implementation of matrix multiply. +- * Allows transposition of either matrix, so it +- * can compute A.B or Trans(A).B or A.Trans(B) or Trans(A).Trans(B) +- * +- * exceptions: GSL_EBADLEN +- */ +-int gsl_linalg_matmult_mod (const gsl_matrix * A, +- gsl_linalg_matrix_mod_t modA, +- const gsl_matrix * B, +- gsl_linalg_matrix_mod_t modB, +- gsl_matrix * C); +- +-/* Calculate the matrix exponential by the scaling and +- * squaring method described in Moler + Van Loan, +- * SIAM Rev 20, 801 (1978). The mode argument allows +- * choosing an optimal strategy, from the table +- * given in the paper, for a given precision. +- * +- * exceptions: GSL_ENOTSQR, GSL_EBADLEN +- */ +-int gsl_linalg_exponential_ss( +- const gsl_matrix * A, +- gsl_matrix * eA, +- gsl_mode_t mode +- ); +- +- +-/* Householder Transformations */ +- +-double gsl_linalg_householder_transform (gsl_vector * v); +-gsl_complex gsl_linalg_complex_householder_transform (gsl_vector_complex * v); +- +-int gsl_linalg_householder_hm (double tau, +- const gsl_vector * v, +- gsl_matrix * A); +- +-int gsl_linalg_householder_mh (double tau, +- const gsl_vector * v, +- gsl_matrix * A); +- +-int gsl_linalg_householder_hv (double tau, +- const gsl_vector * v, +- gsl_vector * w); +- +-int gsl_linalg_householder_hm1 (double tau, +- gsl_matrix * A); +- +-int gsl_linalg_complex_householder_hm (gsl_complex tau, +- const gsl_vector_complex * v, +- gsl_matrix_complex * A); +- +-int gsl_linalg_complex_householder_mh (gsl_complex tau, +- const gsl_vector_complex * v, +- gsl_matrix_complex * A); +- +-int gsl_linalg_complex_householder_hv (gsl_complex tau, +- const gsl_vector_complex * v, +- gsl_vector_complex * w); +- +-/* Hessenberg reduction */ +- +-int gsl_linalg_hessenberg_decomp(gsl_matrix *A, gsl_vector *tau); +-int gsl_linalg_hessenberg_unpack(gsl_matrix * H, gsl_vector * tau, +- gsl_matrix * U); +-int gsl_linalg_hessenberg_unpack_accum(gsl_matrix * H, gsl_vector * tau, +- gsl_matrix * U); +-int gsl_linalg_hessenberg_set_zero(gsl_matrix * H); +-int gsl_linalg_hessenberg_submatrix(gsl_matrix *M, gsl_matrix *A, +- size_t top, gsl_vector *tau); +- +-/* To support gsl-1.9 interface: DEPRECATED */ +-int gsl_linalg_hessenberg(gsl_matrix *A, gsl_vector *tau); +- +- +-/* Hessenberg-Triangular reduction */ +- +-int gsl_linalg_hesstri_decomp(gsl_matrix * A, gsl_matrix * B, +- gsl_matrix * U, gsl_matrix * V, +- gsl_vector * work); +- +-/* Singular Value Decomposition +- +- * exceptions: +- */ +- +-int +-gsl_linalg_SV_decomp (gsl_matrix * A, +- gsl_matrix * V, +- gsl_vector * S, +- gsl_vector * work); +- +-int +-gsl_linalg_SV_decomp_mod (gsl_matrix * A, +- gsl_matrix * X, +- gsl_matrix * V, +- gsl_vector * S, +- gsl_vector * work); +- +-int gsl_linalg_SV_decomp_jacobi (gsl_matrix * A, +- gsl_matrix * Q, +- gsl_vector * S); +- +-int +-gsl_linalg_SV_solve (const gsl_matrix * U, +- const gsl_matrix * Q, +- const gsl_vector * S, +- const gsl_vector * b, +- gsl_vector * x); +- +- +-/* LU Decomposition, Gaussian elimination with partial pivoting +- */ +- +-int gsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation * p, int *signum); +- +-int gsl_linalg_LU_solve (const gsl_matrix * LU, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_LU_svx (const gsl_matrix * LU, +- const gsl_permutation * p, +- gsl_vector * x); +- +-int gsl_linalg_LU_refine (const gsl_matrix * A, +- const gsl_matrix * LU, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x, +- gsl_vector * residual); +- +-int gsl_linalg_LU_invert (const gsl_matrix * LU, +- const gsl_permutation * p, +- gsl_matrix * inverse); +- +-double gsl_linalg_LU_det (gsl_matrix * LU, int signum); +-double gsl_linalg_LU_lndet (gsl_matrix * LU); +-int gsl_linalg_LU_sgndet (gsl_matrix * lu, int signum); +- +-/* Complex LU Decomposition */ +- +-int gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A, +- gsl_permutation * p, +- int *signum); +- +-int gsl_linalg_complex_LU_solve (const gsl_matrix_complex * LU, +- const gsl_permutation * p, +- const gsl_vector_complex * b, +- gsl_vector_complex * x); +- +-int gsl_linalg_complex_LU_svx (const gsl_matrix_complex * LU, +- const gsl_permutation * p, +- gsl_vector_complex * x); +- +-int gsl_linalg_complex_LU_refine (const gsl_matrix_complex * A, +- const gsl_matrix_complex * LU, +- const gsl_permutation * p, +- const gsl_vector_complex * b, +- gsl_vector_complex * x, +- gsl_vector_complex * residual); +- +-int gsl_linalg_complex_LU_invert (const gsl_matrix_complex * LU, +- const gsl_permutation * p, +- gsl_matrix_complex * inverse); +- +-gsl_complex gsl_linalg_complex_LU_det (gsl_matrix_complex * LU, +- int signum); +- +-double gsl_linalg_complex_LU_lndet (gsl_matrix_complex * LU); +- +-gsl_complex gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU, +- int signum); +- +-/* QR decomposition */ +- +-int gsl_linalg_QR_decomp (gsl_matrix * A, +- gsl_vector * tau); +- +-int gsl_linalg_QR_solve (const gsl_matrix * QR, +- const gsl_vector * tau, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_QR_svx (const gsl_matrix * QR, +- const gsl_vector * tau, +- gsl_vector * x); +- +-int gsl_linalg_QR_lssolve (const gsl_matrix * QR, +- const gsl_vector * tau, +- const gsl_vector * b, +- gsl_vector * x, +- gsl_vector * residual); +- +- +-int gsl_linalg_QR_QRsolve (gsl_matrix * Q, +- gsl_matrix * R, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_QR_Rsolve (const gsl_matrix * QR, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_QR_Rsvx (const gsl_matrix * QR, +- gsl_vector * x); +- +-int gsl_linalg_QR_update (gsl_matrix * Q, +- gsl_matrix * R, +- gsl_vector * w, +- const gsl_vector * v); +- +-int gsl_linalg_QR_QTvec (const gsl_matrix * QR, +- const gsl_vector * tau, +- gsl_vector * v); +- +-int gsl_linalg_QR_Qvec (const gsl_matrix * QR, +- const gsl_vector * tau, +- gsl_vector * v); +- +-int gsl_linalg_QR_QTmat (const gsl_matrix * QR, +- const gsl_vector * tau, +- gsl_matrix * A); +- +-int gsl_linalg_QR_unpack (const gsl_matrix * QR, +- const gsl_vector * tau, +- gsl_matrix * Q, +- gsl_matrix * R); +- +-int gsl_linalg_R_solve (const gsl_matrix * R, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_R_svx (const gsl_matrix * R, +- gsl_vector * x); +- +- +-/* Q R P^T decomposition */ +- +-int gsl_linalg_QRPT_decomp (gsl_matrix * A, +- gsl_vector * tau, +- gsl_permutation * p, +- int *signum, +- gsl_vector * norm); +- +-int gsl_linalg_QRPT_decomp2 (const gsl_matrix * A, +- gsl_matrix * q, gsl_matrix * r, +- gsl_vector * tau, +- gsl_permutation * p, +- int *signum, +- gsl_vector * norm); +- +-int gsl_linalg_QRPT_solve (const gsl_matrix * QR, +- const gsl_vector * tau, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +- +-int gsl_linalg_QRPT_svx (const gsl_matrix * QR, +- const gsl_vector * tau, +- const gsl_permutation * p, +- gsl_vector * x); +- +-int gsl_linalg_QRPT_QRsolve (const gsl_matrix * Q, +- const gsl_matrix * R, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_QRPT_Rsolve (const gsl_matrix * QR, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_QRPT_Rsvx (const gsl_matrix * QR, +- const gsl_permutation * p, +- gsl_vector * x); +- +-int gsl_linalg_QRPT_update (gsl_matrix * Q, +- gsl_matrix * R, +- const gsl_permutation * p, +- gsl_vector * u, +- const gsl_vector * v); +- +-/* LQ decomposition */ +- +-int gsl_linalg_LQ_decomp (gsl_matrix * A, gsl_vector * tau); +- +-int gsl_linalg_LQ_solve_T (const gsl_matrix * LQ, const gsl_vector * tau, +- const gsl_vector * b, gsl_vector * x); +- +-int gsl_linalg_LQ_svx_T (const gsl_matrix * LQ, const gsl_vector * tau, +- gsl_vector * x); +- +-int gsl_linalg_LQ_lssolve_T (const gsl_matrix * LQ, const gsl_vector * tau, +- const gsl_vector * b, gsl_vector * x, +- gsl_vector * residual); +- +-int gsl_linalg_LQ_Lsolve_T (const gsl_matrix * LQ, const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_LQ_Lsvx_T (const gsl_matrix * LQ, gsl_vector * x); +- +-int gsl_linalg_L_solve_T (const gsl_matrix * L, const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_LQ_vecQ (const gsl_matrix * LQ, const gsl_vector * tau, +- gsl_vector * v); +- +-int gsl_linalg_LQ_vecQT (const gsl_matrix * LQ, const gsl_vector * tau, +- gsl_vector * v); +- +-int gsl_linalg_LQ_unpack (const gsl_matrix * LQ, const gsl_vector * tau, +- gsl_matrix * Q, gsl_matrix * L); +- +-int gsl_linalg_LQ_update (gsl_matrix * Q, gsl_matrix * R, +- const gsl_vector * v, gsl_vector * w); +-int gsl_linalg_LQ_LQsolve (gsl_matrix * Q, gsl_matrix * L, +- const gsl_vector * b, gsl_vector * x); +- +-/* P^T L Q decomposition */ +- +-int gsl_linalg_PTLQ_decomp (gsl_matrix * A, gsl_vector * tau, +- gsl_permutation * p, int *signum, +- gsl_vector * norm); +- +-int gsl_linalg_PTLQ_decomp2 (const gsl_matrix * A, gsl_matrix * q, +- gsl_matrix * r, gsl_vector * tau, +- gsl_permutation * p, int *signum, +- gsl_vector * norm); +- +-int gsl_linalg_PTLQ_solve_T (const gsl_matrix * QR, +- const gsl_vector * tau, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_PTLQ_svx_T (const gsl_matrix * LQ, +- const gsl_vector * tau, +- const gsl_permutation * p, +- gsl_vector * x); +- +-int gsl_linalg_PTLQ_LQsolve_T (const gsl_matrix * Q, const gsl_matrix * L, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_PTLQ_Lsolve_T (const gsl_matrix * LQ, +- const gsl_permutation * p, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_PTLQ_Lsvx_T (const gsl_matrix * LQ, +- const gsl_permutation * p, +- gsl_vector * x); +- +-int gsl_linalg_PTLQ_update (gsl_matrix * Q, gsl_matrix * L, +- const gsl_permutation * p, +- const gsl_vector * v, gsl_vector * w); +- +-/* Cholesky Decomposition */ +- +-int gsl_linalg_cholesky_decomp (gsl_matrix * A); +- +-int gsl_linalg_cholesky_solve (const gsl_matrix * cholesky, +- const gsl_vector * b, +- gsl_vector * x); +- +-int gsl_linalg_cholesky_svx (const gsl_matrix * cholesky, +- gsl_vector * x); +- +-int gsl_linalg_cholesky_invert(gsl_matrix * cholesky); +- +-/* Cholesky decomposition with unit-diagonal triangular parts. +- * A = L D L^T, where diag(L) = (1,1,...,1). +- * Upon exit, A contains L and L^T as for Cholesky, and +- * the diagonal of A is (1,1,...,1). The vector Dis set +- * to the diagonal elements of the diagonal matrix D. +- */ +-int gsl_linalg_cholesky_decomp_unit(gsl_matrix * A, gsl_vector * D); +- +-/* Complex Cholesky Decomposition */ +- +-int gsl_linalg_complex_cholesky_decomp (gsl_matrix_complex * A); +- +-int gsl_linalg_complex_cholesky_solve (const gsl_matrix_complex * cholesky, +- const gsl_vector_complex * b, +- gsl_vector_complex * x); +- +-int gsl_linalg_complex_cholesky_svx (const gsl_matrix_complex * cholesky, +- gsl_vector_complex * x); +- +-int gsl_linalg_complex_cholesky_invert(gsl_matrix_complex * cholesky); +- +- +-/* Symmetric to symmetric tridiagonal decomposition */ +- +-int gsl_linalg_symmtd_decomp (gsl_matrix * A, +- gsl_vector * tau); +- +-int gsl_linalg_symmtd_unpack (const gsl_matrix * A, +- const gsl_vector * tau, +- gsl_matrix * Q, +- gsl_vector * diag, +- gsl_vector * subdiag); +- +-int gsl_linalg_symmtd_unpack_T (const gsl_matrix * A, +- gsl_vector * diag, +- gsl_vector * subdiag); +- +-/* Hermitian to symmetric tridiagonal decomposition */ +- +-int gsl_linalg_hermtd_decomp (gsl_matrix_complex * A, +- gsl_vector_complex * tau); +- +-int gsl_linalg_hermtd_unpack (const gsl_matrix_complex * A, +- const gsl_vector_complex * tau, +- gsl_matrix_complex * U, +- gsl_vector * diag, +- gsl_vector * sudiag); +- +-int gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex * A, +- gsl_vector * diag, +- gsl_vector * subdiag); +- +-/* Linear Solve Using Householder Transformations +- +- * exceptions: +- */ +- +-int gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector * b, gsl_vector * x); +-int gsl_linalg_HH_svx (gsl_matrix * A, gsl_vector * x); +- +-/* Linear solve for a symmetric tridiagonal system. +- +- * The input vectors represent the NxN matrix as follows: +- * +- * diag[0] offdiag[0] 0 ... +- * offdiag[0] diag[1] offdiag[1] ... +- * 0 offdiag[1] diag[2] ... +- * 0 0 offdiag[2] ... +- * ... ... ... ... +- */ +-int gsl_linalg_solve_symm_tridiag (const gsl_vector * diag, +- const gsl_vector * offdiag, +- const gsl_vector * b, +- gsl_vector * x); +- +-/* Linear solve for a nonsymmetric tridiagonal system. +- +- * The input vectors represent the NxN matrix as follows: +- * +- * diag[0] abovediag[0] 0 ... +- * belowdiag[0] diag[1] abovediag[1] ... +- * 0 belowdiag[1] diag[2] ... +- * 0 0 belowdiag[2] ... +- * ... ... ... ... +- */ +-int gsl_linalg_solve_tridiag (const gsl_vector * diag, +- const gsl_vector * abovediag, +- const gsl_vector * belowdiag, +- const gsl_vector * b, +- gsl_vector * x); +- +- +-/* Linear solve for a symmetric cyclic tridiagonal system. +- +- * The input vectors represent the NxN matrix as follows: +- * +- * diag[0] offdiag[0] 0 ..... offdiag[N-1] +- * offdiag[0] diag[1] offdiag[1] ..... +- * 0 offdiag[1] diag[2] ..... +- * 0 0 offdiag[2] ..... +- * ... ... +- * offdiag[N-1] ... +- */ +-int gsl_linalg_solve_symm_cyc_tridiag (const gsl_vector * diag, +- const gsl_vector * offdiag, +- const gsl_vector * b, +- gsl_vector * x); +- +-/* Linear solve for a nonsymmetric cyclic tridiagonal system. +- +- * The input vectors represent the NxN matrix as follows: +- * +- * diag[0] abovediag[0] 0 ..... belowdiag[N-1] +- * belowdiag[0] diag[1] abovediag[1] ..... +- * 0 belowdiag[1] diag[2] +- * 0 0 belowdiag[2] ..... +- * ... ... +- * abovediag[N-1] ... +- */ +-int gsl_linalg_solve_cyc_tridiag (const gsl_vector * diag, +- const gsl_vector * abovediag, +- const gsl_vector * belowdiag, +- const gsl_vector * b, +- gsl_vector * x); +- +- +-/* Bidiagonal decomposition */ +- +-int gsl_linalg_bidiag_decomp (gsl_matrix * A, +- gsl_vector * tau_U, +- gsl_vector * tau_V); +- +-int gsl_linalg_bidiag_unpack (const gsl_matrix * A, +- const gsl_vector * tau_U, +- gsl_matrix * U, +- const gsl_vector * tau_V, +- gsl_matrix * V, +- gsl_vector * diag, +- gsl_vector * superdiag); +- +-int gsl_linalg_bidiag_unpack2 (gsl_matrix * A, +- gsl_vector * tau_U, +- gsl_vector * tau_V, +- gsl_matrix * V); +- +-int gsl_linalg_bidiag_unpack_B (const gsl_matrix * A, +- gsl_vector * diag, +- gsl_vector * superdiag); +- +-/* Balancing */ +- +-int gsl_linalg_balance_matrix (gsl_matrix * A, gsl_vector * D); +-int gsl_linalg_balance_accum (gsl_matrix * A, gsl_vector * D); +-int gsl_linalg_balance_columns (gsl_matrix * A, gsl_vector * D); +- +- +-__END_DECLS +- +-#endif /* __GSL_LINALG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_roots.h (revision 14079) +@@ -1,127 +0,0 @@ +-/* roots/gsl_roots.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Reid Priedhorsky, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_ROOTS_H__ +-#define __GSL_ROOTS_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*set) (void *state, gsl_function * f, double * root, double x_lower, double x_upper); +- int (*iterate) (void *state, gsl_function * f, double * root, double * x_lower, double * x_upper); +- } +-gsl_root_fsolver_type; +- +-typedef struct +- { +- const gsl_root_fsolver_type * type; +- gsl_function * function ; +- double root ; +- double x_lower; +- double x_upper; +- void *state; +- } +-gsl_root_fsolver; +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*set) (void *state, gsl_function_fdf * f, double * root); +- int (*iterate) (void *state, gsl_function_fdf * f, double * root); +- } +-gsl_root_fdfsolver_type; +- +-typedef struct +- { +- const gsl_root_fdfsolver_type * type; +- gsl_function_fdf * fdf ; +- double root ; +- void *state; +- } +-gsl_root_fdfsolver; +- +-gsl_root_fsolver * +-gsl_root_fsolver_alloc (const gsl_root_fsolver_type * T); +-void gsl_root_fsolver_free (gsl_root_fsolver * s); +- +-int gsl_root_fsolver_set (gsl_root_fsolver * s, +- gsl_function * f, +- double x_lower, double x_upper); +- +-int gsl_root_fsolver_iterate (gsl_root_fsolver * s); +- +-const char * gsl_root_fsolver_name (const gsl_root_fsolver * s); +-double gsl_root_fsolver_root (const gsl_root_fsolver * s); +-double gsl_root_fsolver_x_lower (const gsl_root_fsolver * s); +-double gsl_root_fsolver_x_upper (const gsl_root_fsolver * s); +- +- +-gsl_root_fdfsolver * +-gsl_root_fdfsolver_alloc (const gsl_root_fdfsolver_type * T); +- +-int +-gsl_root_fdfsolver_set (gsl_root_fdfsolver * s, +- gsl_function_fdf * fdf, double root); +- +-int +-gsl_root_fdfsolver_iterate (gsl_root_fdfsolver * s); +- +-void +-gsl_root_fdfsolver_free (gsl_root_fdfsolver * s); +- +-const char * gsl_root_fdfsolver_name (const gsl_root_fdfsolver * s); +-double gsl_root_fdfsolver_root (const gsl_root_fdfsolver * s); +- +-int +-gsl_root_test_interval (double x_lower, double x_upper, double epsabs, double epsrel); +- +-int +-gsl_root_test_residual (double f, double epsabs); +- +-int +-gsl_root_test_delta (double x1, double x0, double epsabs, double epsrel); +- +-GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_bisection; +-GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_brent; +-GSL_VAR const gsl_root_fsolver_type * gsl_root_fsolver_falsepos; +-GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_newton; +-GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_secant; +-GSL_VAR const gsl_root_fdfsolver_type * gsl_root_fdfsolver_steffenson; +- +-__END_DECLS +- +-#endif /* __GSL_ROOTS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permutation.h (revision 14079) +@@ -1,100 +0,0 @@ +-/* permutation/gsl_permutation.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTATION_H__ +-#define __GSL_PERMUTATION_H__ +- +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_permutation_struct +-{ +- size_t size; +- size_t *data; +-}; +- +-typedef struct gsl_permutation_struct gsl_permutation; +- +-gsl_permutation *gsl_permutation_alloc (const size_t n); +-gsl_permutation *gsl_permutation_calloc (const size_t n); +-void gsl_permutation_init (gsl_permutation * p); +-void gsl_permutation_free (gsl_permutation * p); +-int gsl_permutation_memcpy (gsl_permutation * dest, const gsl_permutation * src); +- +-int gsl_permutation_fread (FILE * stream, gsl_permutation * p); +-int gsl_permutation_fwrite (FILE * stream, const gsl_permutation * p); +-int gsl_permutation_fscanf (FILE * stream, gsl_permutation * p); +-int gsl_permutation_fprintf (FILE * stream, const gsl_permutation * p, const char *format); +- +-size_t gsl_permutation_size (const gsl_permutation * p); +-size_t * gsl_permutation_data (const gsl_permutation * p); +- +-int gsl_permutation_swap (gsl_permutation * p, const size_t i, const size_t j); +- +-int gsl_permutation_valid (const gsl_permutation * p); +-void gsl_permutation_reverse (gsl_permutation * p); +-int gsl_permutation_inverse (gsl_permutation * inv, const gsl_permutation * p); +-int gsl_permutation_next (gsl_permutation * p); +-int gsl_permutation_prev (gsl_permutation * p); +-int gsl_permutation_mul (gsl_permutation * p, const gsl_permutation * pa, const gsl_permutation * pb); +- +-int gsl_permutation_linear_to_canonical (gsl_permutation * q, const gsl_permutation * p); +-int gsl_permutation_canonical_to_linear (gsl_permutation * p, const gsl_permutation * q); +- +-size_t gsl_permutation_inversions (const gsl_permutation * p); +-size_t gsl_permutation_linear_cycles (const gsl_permutation * p); +-size_t gsl_permutation_canonical_cycles (const gsl_permutation * q); +- +-INLINE_DECL size_t gsl_permutation_get (const gsl_permutation * p, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-size_t +-gsl_permutation_get (const gsl_permutation * p, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= p->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return p->data[i]; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_vegas.h (revision 14079) +@@ -1,125 +0,0 @@ +-/* monte/gsl_monte_vegas.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth +- * Copyright (C) 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* header for the gsl "vegas" routines. Mike Booth, May 1998 */ +- +-#ifndef __GSL_MONTE_VEGAS_H__ +-#define __GSL_MONTE_VEGAS_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-enum {GSL_VEGAS_MODE_IMPORTANCE = 1, +- GSL_VEGAS_MODE_IMPORTANCE_ONLY = 0, +- GSL_VEGAS_MODE_STRATIFIED = -1}; +- +-typedef struct { +- /* grid */ +- size_t dim; +- size_t bins_max; +- unsigned int bins; +- unsigned int boxes; /* these are both counted along the axes */ +- double * xi; +- double * xin; +- double * delx; +- double * weight; +- double vol; +- +- double * x; +- int * bin; +- int * box; +- +- /* distribution */ +- double * d; +- +- /* control variables */ +- double alpha; +- int mode; +- int verbose; +- unsigned int iterations; +- int stage; +- +- /* scratch variables preserved between calls to vegas1/2/3 */ +- double jac; +- double wtd_int_sum; +- double sum_wgts; +- double chi_sum; +- double chisq; +- +- double result; +- double sigma; +- +- unsigned int it_start; +- unsigned int it_num; +- unsigned int samples; +- unsigned int calls_per_box; +- +- FILE * ostream; +- +-} gsl_monte_vegas_state; +- +-int gsl_monte_vegas_integrate(gsl_monte_function * f, +- double xl[], double xu[], +- size_t dim, size_t calls, +- gsl_rng * r, +- gsl_monte_vegas_state *state, +- double* result, double* abserr); +- +-gsl_monte_vegas_state* gsl_monte_vegas_alloc(size_t dim); +- +-int gsl_monte_vegas_init(gsl_monte_vegas_state* state); +- +-void gsl_monte_vegas_free (gsl_monte_vegas_state* state); +- +-double gsl_monte_vegas_chisq (const gsl_monte_vegas_state* state); +-void gsl_monte_vegas_runval (const gsl_monte_vegas_state* state, double * result, double * sigma); +- +-typedef struct { +- double alpha; +- size_t iterations; +- int stage; +- int mode; +- int verbose; +- FILE * ostream; +-} gsl_monte_vegas_params; +- +-void gsl_monte_vegas_params_get (const gsl_monte_vegas_state * state, +- gsl_monte_vegas_params * params); +- +-void gsl_monte_vegas_params_set (gsl_monte_vegas_state * state, +- const gsl_monte_vegas_params * params); +- +-__END_DECLS +- +-#endif /* __GSL_MONTE_VEGAS_H__ */ +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ushort.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_USHORT_H__ +-#define __GSL_MATRIX_USHORT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- unsigned short * data; +- gsl_block_ushort * block; +- int owner; +-} gsl_matrix_ushort; +- +-typedef struct +-{ +- gsl_matrix_ushort matrix; +-} _gsl_matrix_ushort_view; +- +-typedef _gsl_matrix_ushort_view gsl_matrix_ushort_view; +- +-typedef struct +-{ +- gsl_matrix_ushort matrix; +-} _gsl_matrix_ushort_const_view; +- +-typedef const _gsl_matrix_ushort_const_view gsl_matrix_ushort_const_view; +- +-/* Allocation */ +- +-gsl_matrix_ushort * +-gsl_matrix_ushort_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_ushort * +-gsl_matrix_ushort_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_ushort * +-gsl_matrix_ushort_alloc_from_block (gsl_block_ushort * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_ushort * +-gsl_matrix_ushort_alloc_from_matrix (gsl_matrix_ushort * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_ushort * +-gsl_vector_ushort_alloc_row_from_matrix (gsl_matrix_ushort * m, +- const size_t i); +- +-gsl_vector_ushort * +-gsl_vector_ushort_alloc_col_from_matrix (gsl_matrix_ushort * m, +- const size_t j); +- +-void gsl_matrix_ushort_free (gsl_matrix_ushort * m); +- +-/* Views */ +- +-_gsl_matrix_ushort_view +-gsl_matrix_ushort_submatrix (gsl_matrix_ushort * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_row (gsl_matrix_ushort * m, const size_t i); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_column (gsl_matrix_ushort * m, const size_t j); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_diagonal (gsl_matrix_ushort * m); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_subdiagonal (gsl_matrix_ushort * m, const size_t k); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_superdiagonal (gsl_matrix_ushort * m, const size_t k); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_subrow (gsl_matrix_ushort * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_ushort_view +-gsl_matrix_ushort_subcolumn (gsl_matrix_ushort * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_ushort_view +-gsl_matrix_ushort_view_array (unsigned short * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ushort_view +-gsl_matrix_ushort_view_array_with_tda (unsigned short * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_ushort_view +-gsl_matrix_ushort_view_vector (gsl_vector_ushort * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ushort_view +-gsl_matrix_ushort_view_vector_with_tda (gsl_vector_ushort * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_ushort_const_view +-gsl_matrix_ushort_const_submatrix (const gsl_matrix_ushort * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_row (const gsl_matrix_ushort * m, +- const size_t i); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_column (const gsl_matrix_ushort * m, +- const size_t j); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_diagonal (const gsl_matrix_ushort * m); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_subdiagonal (const gsl_matrix_ushort * m, +- const size_t k); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_superdiagonal (const gsl_matrix_ushort * m, +- const size_t k); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_subrow (const gsl_matrix_ushort * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_ushort_const_view +-gsl_matrix_ushort_const_subcolumn (const gsl_matrix_ushort * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_ushort_const_view +-gsl_matrix_ushort_const_view_array (const unsigned short * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ushort_const_view +-gsl_matrix_ushort_const_view_array_with_tda (const unsigned short * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_ushort_const_view +-gsl_matrix_ushort_const_view_vector (const gsl_vector_ushort * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ushort_const_view +-gsl_matrix_ushort_const_view_vector_with_tda (const gsl_vector_ushort * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_ushort_set_zero (gsl_matrix_ushort * m); +-void gsl_matrix_ushort_set_identity (gsl_matrix_ushort * m); +-void gsl_matrix_ushort_set_all (gsl_matrix_ushort * m, unsigned short x); +- +-int gsl_matrix_ushort_fread (FILE * stream, gsl_matrix_ushort * m) ; +-int gsl_matrix_ushort_fwrite (FILE * stream, const gsl_matrix_ushort * m) ; +-int gsl_matrix_ushort_fscanf (FILE * stream, gsl_matrix_ushort * m); +-int gsl_matrix_ushort_fprintf (FILE * stream, const gsl_matrix_ushort * m, const char * format); +- +-int gsl_matrix_ushort_memcpy(gsl_matrix_ushort * dest, const gsl_matrix_ushort * src); +-int gsl_matrix_ushort_swap(gsl_matrix_ushort * m1, gsl_matrix_ushort * m2); +- +-int gsl_matrix_ushort_swap_rows(gsl_matrix_ushort * m, const size_t i, const size_t j); +-int gsl_matrix_ushort_swap_columns(gsl_matrix_ushort * m, const size_t i, const size_t j); +-int gsl_matrix_ushort_swap_rowcol(gsl_matrix_ushort * m, const size_t i, const size_t j); +-int gsl_matrix_ushort_transpose (gsl_matrix_ushort * m); +-int gsl_matrix_ushort_transpose_memcpy (gsl_matrix_ushort * dest, const gsl_matrix_ushort * src); +- +-unsigned short gsl_matrix_ushort_max (const gsl_matrix_ushort * m); +-unsigned short gsl_matrix_ushort_min (const gsl_matrix_ushort * m); +-void gsl_matrix_ushort_minmax (const gsl_matrix_ushort * m, unsigned short * min_out, unsigned short * max_out); +- +-void gsl_matrix_ushort_max_index (const gsl_matrix_ushort * m, size_t * imax, size_t *jmax); +-void gsl_matrix_ushort_min_index (const gsl_matrix_ushort * m, size_t * imin, size_t *jmin); +-void gsl_matrix_ushort_minmax_index (const gsl_matrix_ushort * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_ushort_equal (const gsl_matrix_ushort * a, const gsl_matrix_ushort * b); +- +-int gsl_matrix_ushort_isnull (const gsl_matrix_ushort * m); +-int gsl_matrix_ushort_ispos (const gsl_matrix_ushort * m); +-int gsl_matrix_ushort_isneg (const gsl_matrix_ushort * m); +-int gsl_matrix_ushort_isnonneg (const gsl_matrix_ushort * m); +- +-int gsl_matrix_ushort_add (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); +-int gsl_matrix_ushort_sub (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); +-int gsl_matrix_ushort_mul_elements (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); +-int gsl_matrix_ushort_div_elements (gsl_matrix_ushort * a, const gsl_matrix_ushort * b); +-int gsl_matrix_ushort_scale (gsl_matrix_ushort * a, const double x); +-int gsl_matrix_ushort_add_constant (gsl_matrix_ushort * a, const double x); +-int gsl_matrix_ushort_add_diagonal (gsl_matrix_ushort * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_ushort_get_row(gsl_vector_ushort * v, const gsl_matrix_ushort * m, const size_t i); +-int gsl_matrix_ushort_get_col(gsl_vector_ushort * v, const gsl_matrix_ushort * m, const size_t j); +-int gsl_matrix_ushort_set_row(gsl_matrix_ushort * m, const size_t i, const gsl_vector_ushort * v); +-int gsl_matrix_ushort_set_col(gsl_matrix_ushort * m, const size_t j, const gsl_vector_ushort * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL unsigned short gsl_matrix_ushort_get(const gsl_matrix_ushort * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_ushort_set(gsl_matrix_ushort * m, const size_t i, const size_t j, const unsigned short x); +-INLINE_DECL unsigned short * gsl_matrix_ushort_ptr(gsl_matrix_ushort * m, const size_t i, const size_t j); +-INLINE_DECL const unsigned short * gsl_matrix_ushort_const_ptr(const gsl_matrix_ushort * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-unsigned short +-gsl_matrix_ushort_get(const gsl_matrix_ushort * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_ushort_set(gsl_matrix_ushort * m, const size_t i, const size_t j, const unsigned short x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-unsigned short * +-gsl_matrix_ushort_ptr(gsl_matrix_ushort * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (unsigned short *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const unsigned short * +-gsl_matrix_ushort_const_ptr(const gsl_matrix_ushort * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const unsigned short *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_short.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_SHORT_H__ +-#define __GSL_STATISTICS_SHORT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_short_mean (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_variance (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_sd (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_variance_with_fixed_mean (const short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_short_sd_with_fixed_mean (const short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_short_tss (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_tss_m (const short data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_short_absdev (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_skew (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_kurtosis (const short data[], const size_t stride, const size_t n); +-double gsl_stats_short_lag1_autocorrelation (const short data[], const size_t stride, const size_t n); +- +-double gsl_stats_short_covariance (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n); +-double gsl_stats_short_correlation (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_short_variance_m (const short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_short_sd_m (const short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_short_absdev_m (const short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_short_skew_m_sd (const short data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_short_kurtosis_m_sd (const short data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_short_lag1_autocorrelation_m (const short data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_short_covariance_m (const short data1[], const size_t stride1,const short data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_short_pvariance (const short data1[], const size_t stride1, const size_t n1, const short data2[], const size_t stride2, const size_t n2); +-double gsl_stats_short_ttest (const short data1[], const size_t stride1, const size_t n1, const short data2[], const size_t stride2, const size_t n2); +- +-short gsl_stats_short_max (const short data[], const size_t stride, const size_t n); +-short gsl_stats_short_min (const short data[], const size_t stride, const size_t n); +-void gsl_stats_short_minmax (short * min, short * max, const short data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_short_max_index (const short data[], const size_t stride, const size_t n); +-size_t gsl_stats_short_min_index (const short data[], const size_t stride, const size_t n); +-void gsl_stats_short_minmax_index (size_t * min_index, size_t * max_index, const short data[], const size_t stride, const size_t n); +- +-double gsl_stats_short_median_from_sorted_data (const short sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_short_quantile_from_sorted_data (const short sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_nan.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* gsl_nan.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_NAN_H__ +-#define __GSL_NAN_H__ +- +-#ifdef INFINITY +-# define GSL_POSINF INFINITY +-# define GSL_NEGINF (-INFINITY) +-#elif defined(HUGE_VAL) +-# define GSL_POSINF HUGE_VAL +-# define GSL_NEGINF (-HUGE_VAL) +-#else +-# define GSL_POSINF (gsl_posinf()) +-# define GSL_NEGINF (gsl_neginf()) +-#endif +- +-#ifdef NAN +-# define GSL_NAN NAN +-#elif defined(INFINITY) +-# define GSL_NAN (INFINITY/INFINITY) +-#else +-# define GSL_NAN (gsl_nan()) +-#endif +- +-#define GSL_POSZERO (+0.0) +-#define GSL_NEGZERO (-0.0) +- +-#endif /* __GSL_NAN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_int.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_INT_H__ +-#define __GSL_PERMUTE_VECTOR_INT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_int (const gsl_permutation * p, gsl_vector_int * v); +-int gsl_permute_vector_int_inverse (const gsl_permutation * p, gsl_vector_int * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_legendre.h (revision 14079) +@@ -1,315 +0,0 @@ +-/* specfunc/gsl_sf_legendre.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_LEGENDRE_H__ +-#define __GSL_SF_LEGENDRE_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* P_l(x) l >= 0; |x| <= 1 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Pl_e(const int l, const double x, gsl_sf_result * result); +-double gsl_sf_legendre_Pl(const int l, const double x); +- +- +-/* P_l(x) for l=0,...,lmax; |x| <= 1 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Pl_array( +- const int lmax, const double x, +- double * result_array +- ); +- +- +-/* P_l(x) and P_l'(x) for l=0,...,lmax; |x| <= 1 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Pl_deriv_array( +- const int lmax, const double x, +- double * result_array, +- double * result_deriv_array +- ); +- +- +-/* P_l(x), l=1,2,3 +- * +- * exceptions: none +- */ +-int gsl_sf_legendre_P1_e(double x, gsl_sf_result * result); +-int gsl_sf_legendre_P2_e(double x, gsl_sf_result * result); +-int gsl_sf_legendre_P3_e(double x, gsl_sf_result * result); +-double gsl_sf_legendre_P1(const double x); +-double gsl_sf_legendre_P2(const double x); +-double gsl_sf_legendre_P3(const double x); +- +- +-/* Q_0(x), x > -1, x != 1 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Q0_e(const double x, gsl_sf_result * result); +-double gsl_sf_legendre_Q0(const double x); +- +- +-/* Q_1(x), x > -1, x != 1 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Q1_e(const double x, gsl_sf_result * result); +-double gsl_sf_legendre_Q1(const double x); +- +- +-/* Q_l(x), x > -1, x != 1, l >= 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_Ql_e(const int l, const double x, gsl_sf_result * result); +-double gsl_sf_legendre_Ql(const int l, const double x); +- +- +-/* P_l^m(x) m >= 0; l >= m; |x| <= 1.0 +- * +- * Note that this function grows combinatorially with l. +- * Therefore we can easily generate an overflow for l larger +- * than about 150. +- * +- * There is no trouble for small m, but when m and l are both large, +- * then there will be trouble. Rather than allow overflows, these +- * functions refuse to calculate when they can sense that l and m are +- * too big. +- * +- * If you really want to calculate a spherical harmonic, then DO NOT +- * use this. Instead use legendre_sphPlm() below, which uses a similar +- * recursion, but with the normalized functions. +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_legendre_Plm_e(const int l, const int m, const double x, gsl_sf_result * result); +-double gsl_sf_legendre_Plm(const int l, const int m, const double x); +- +- +-/* P_l^m(x) m >= 0; l >= m; |x| <= 1.0 +- * l=|m|,...,lmax +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_legendre_Plm_array( +- const int lmax, const int m, const double x, +- double * result_array +- ); +- +- +-/* P_l^m(x) and d(P_l^m(x))/dx; m >= 0; lmax >= m; |x| <= 1.0 +- * l=|m|,...,lmax +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_legendre_Plm_deriv_array( +- const int lmax, const int m, const double x, +- double * result_array, +- double * result_deriv_array +- ); +- +- +-/* P_l^m(x), normalized properly for use in spherical harmonics +- * m >= 0; l >= m; |x| <= 1.0 +- * +- * There is no overflow problem, as there is for the +- * standard normalization of P_l^m(x). +- * +- * Specifically, it returns: +- * +- * sqrt((2l+1)/(4pi)) sqrt((l-m)!/(l+m)!) P_l^m(x) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_sphPlm_e(const int l, int m, const double x, gsl_sf_result * result); +-double gsl_sf_legendre_sphPlm(const int l, const int m, const double x); +- +- +-/* sphPlm(l,m,x) values +- * m >= 0; l >= m; |x| <= 1.0 +- * l=|m|,...,lmax +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_sphPlm_array( +- const int lmax, int m, const double x, +- double * result_array +- ); +- +- +-/* sphPlm(l,m,x) and d(sphPlm(l,m,x))/dx values +- * m >= 0; l >= m; |x| <= 1.0 +- * l=|m|,...,lmax +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_sphPlm_deriv_array( +- const int lmax, const int m, const double x, +- double * result_array, +- double * result_deriv_array +- ); +- +- +- +-/* size of result_array[] needed for the array versions of Plm +- * (lmax - m + 1) +- */ +-int gsl_sf_legendre_array_size(const int lmax, const int m); +- +-/* Irregular Spherical Conical Function +- * P^{1/2}_{-1/2 + I lambda}(x) +- * +- * x > -1.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_half_e(const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_half(const double lambda, const double x); +- +- +-/* Regular Spherical Conical Function +- * P^{-1/2}_{-1/2 + I lambda}(x) +- * +- * x > -1.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_mhalf_e(const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_mhalf(const double lambda, const double x); +- +- +-/* Conical Function +- * P^{0}_{-1/2 + I lambda}(x) +- * +- * x > -1.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_0_e(const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_0(const double lambda, const double x); +- +- +-/* Conical Function +- * P^{1}_{-1/2 + I lambda}(x) +- * +- * x > -1.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_1_e(const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_1(const double lambda, const double x); +- +- +-/* Regular Spherical Conical Function +- * P^{-1/2-l}_{-1/2 + I lambda}(x) +- * +- * x > -1.0, l >= -1 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_sph_reg_e(const int l, const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_sph_reg(const int l, const double lambda, const double x); +- +- +-/* Regular Cylindrical Conical Function +- * P^{-m}_{-1/2 + I lambda}(x) +- * +- * x > -1.0, m >= -1 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_conicalP_cyl_reg_e(const int m, const double lambda, const double x, gsl_sf_result * result); +-double gsl_sf_conicalP_cyl_reg(const int m, const double lambda, const double x); +- +- +-/* The following spherical functions are specializations +- * of Legendre functions which give the regular eigenfunctions +- * of the Laplacian on a 3-dimensional hyperbolic space. +- * Of particular interest is the flat limit, which is +- * Flat-Lim := {lambda->Inf, eta->0, lambda*eta fixed}. +- */ +- +-/* Zeroth radial eigenfunction of the Laplacian on the +- * 3-dimensional hyperbolic space. +- * +- * legendre_H3d_0(lambda,eta) := sin(lambda*eta)/(lambda*sinh(eta)) +- * +- * Normalization: +- * Flat-Lim legendre_H3d_0(lambda,eta) = j_0(lambda*eta) +- * +- * eta >= 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_H3d_0_e(const double lambda, const double eta, gsl_sf_result * result); +-double gsl_sf_legendre_H3d_0(const double lambda, const double eta); +- +- +-/* First radial eigenfunction of the Laplacian on the +- * 3-dimensional hyperbolic space. +- * +- * legendre_H3d_1(lambda,eta) := +- * 1/sqrt(lambda^2 + 1) sin(lam eta)/(lam sinh(eta)) +- * (coth(eta) - lambda cot(lambda*eta)) +- * +- * Normalization: +- * Flat-Lim legendre_H3d_1(lambda,eta) = j_1(lambda*eta) +- * +- * eta >= 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_H3d_1_e(const double lambda, const double eta, gsl_sf_result * result); +-double gsl_sf_legendre_H3d_1(const double lambda, const double eta); +- +- +-/* l'th radial eigenfunction of the Laplacian on the +- * 3-dimensional hyperbolic space. +- * +- * Normalization: +- * Flat-Lim legendre_H3d_l(l,lambda,eta) = j_l(lambda*eta) +- * +- * eta >= 0.0, l >= 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_legendre_H3d_e(const int l, const double lambda, const double eta, gsl_sf_result * result); +-double gsl_sf_legendre_H3d(const int l, const double lambda, const double eta); +- +- +-/* Array of H3d(ell), 0 <= ell <= lmax +- */ +-int gsl_sf_legendre_H3d_array(const int lmax, const double lambda, const double eta, double * result_array); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_LEGENDRE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_lambert.h (revision 14079) +@@ -1,69 +0,0 @@ +-/* specfunc/gsl_sf_lambert.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_LAMBERT_H__ +-#define __GSL_SF_LAMBERT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Lambert's Function W_0(x) +- * +- * W_0(x) is the principal branch of the +- * implicit function defined by W e^W = x. +- * +- * -1/E < x < \infty +- * +- * exceptions: GSL_EMAXITER; +- */ +-int gsl_sf_lambert_W0_e(double x, gsl_sf_result * result); +-double gsl_sf_lambert_W0(double x); +- +- +-/* Lambert's Function W_{-1}(x) +- * +- * W_{-1}(x) is the second real branch of the +- * implicit function defined by W e^W = x. +- * It agrees with W_0(x) when x >= 0. +- * +- * -1/E < x < \infty +- * +- * exceptions: GSL_MAXITER; +- */ +-int gsl_sf_lambert_Wm1_e(double x, gsl_sf_result * result); +-double gsl_sf_lambert_Wm1(double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_LAMBERT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_char.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_CHAR_H__ +-#define __GSL_PERMUTE_CHAR_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_char (const size_t * p, char * data, const size_t stride, const size_t n); +-int gsl_permute_char_inverse (const size_t * p, char * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_float.h (revision 14079) +@@ -1,251 +0,0 @@ +-/* vector/gsl_vector_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_COMPLEX_FLOAT_H__ +-#define __GSL_VECTOR_COMPLEX_FLOAT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- float *data; +- gsl_block_complex_float *block; +- int owner; +-} gsl_vector_complex_float; +- +-typedef struct +-{ +- gsl_vector_complex_float vector; +-} _gsl_vector_complex_float_view; +- +-typedef _gsl_vector_complex_float_view gsl_vector_complex_float_view; +- +-typedef struct +-{ +- gsl_vector_complex_float vector; +-} _gsl_vector_complex_float_const_view; +- +-typedef const _gsl_vector_complex_float_const_view gsl_vector_complex_float_const_view; +- +-/* Allocation */ +- +-gsl_vector_complex_float *gsl_vector_complex_float_alloc (const size_t n); +-gsl_vector_complex_float *gsl_vector_complex_float_calloc (const size_t n); +- +-gsl_vector_complex_float * +-gsl_vector_complex_float_alloc_from_block (gsl_block_complex_float * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_complex_float * +-gsl_vector_complex_float_alloc_from_vector (gsl_vector_complex_float * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_complex_float_free (gsl_vector_complex_float * v); +- +-/* Views */ +- +-_gsl_vector_complex_float_view +-gsl_vector_complex_float_view_array (float *base, +- size_t n); +- +-_gsl_vector_complex_float_view +-gsl_vector_complex_float_view_array_with_stride (float *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_float_const_view +-gsl_vector_complex_float_const_view_array (const float *base, +- size_t n); +- +-_gsl_vector_complex_float_const_view +-gsl_vector_complex_float_const_view_array_with_stride (const float *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_float_view +-gsl_vector_complex_float_subvector (gsl_vector_complex_float *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_float_view +-gsl_vector_complex_float_subvector_with_stride (gsl_vector_complex_float *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_float_const_view +-gsl_vector_complex_float_const_subvector (const gsl_vector_complex_float *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_float_const_view +-gsl_vector_complex_float_const_subvector_with_stride (const gsl_vector_complex_float *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_float_view +-gsl_vector_complex_float_real (gsl_vector_complex_float *v); +- +-_gsl_vector_float_view +-gsl_vector_complex_float_imag (gsl_vector_complex_float *v); +- +-_gsl_vector_float_const_view +-gsl_vector_complex_float_const_real (const gsl_vector_complex_float *v); +- +-_gsl_vector_float_const_view +-gsl_vector_complex_float_const_imag (const gsl_vector_complex_float *v); +- +- +-/* Operations */ +- +-void gsl_vector_complex_float_set_zero (gsl_vector_complex_float * v); +-void gsl_vector_complex_float_set_all (gsl_vector_complex_float * v, +- gsl_complex_float z); +-int gsl_vector_complex_float_set_basis (gsl_vector_complex_float * v, size_t i); +- +-int gsl_vector_complex_float_fread (FILE * stream, +- gsl_vector_complex_float * v); +-int gsl_vector_complex_float_fwrite (FILE * stream, +- const gsl_vector_complex_float * v); +-int gsl_vector_complex_float_fscanf (FILE * stream, +- gsl_vector_complex_float * v); +-int gsl_vector_complex_float_fprintf (FILE * stream, +- const gsl_vector_complex_float * v, +- const char *format); +- +-int gsl_vector_complex_float_memcpy (gsl_vector_complex_float * dest, const gsl_vector_complex_float * src); +- +-int gsl_vector_complex_float_reverse (gsl_vector_complex_float * v); +- +-int gsl_vector_complex_float_swap (gsl_vector_complex_float * v, gsl_vector_complex_float * w); +-int gsl_vector_complex_float_swap_elements (gsl_vector_complex_float * v, const size_t i, const size_t j); +- +-int gsl_vector_complex_float_equal (const gsl_vector_complex_float * u, +- const gsl_vector_complex_float * v); +- +-int gsl_vector_complex_float_isnull (const gsl_vector_complex_float * v); +-int gsl_vector_complex_float_ispos (const gsl_vector_complex_float * v); +-int gsl_vector_complex_float_isneg (const gsl_vector_complex_float * v); +-int gsl_vector_complex_float_isnonneg (const gsl_vector_complex_float * v); +- +-int gsl_vector_complex_float_add (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); +-int gsl_vector_complex_float_sub (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); +-int gsl_vector_complex_float_mul (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); +-int gsl_vector_complex_float_div (gsl_vector_complex_float * a, const gsl_vector_complex_float * b); +-int gsl_vector_complex_float_scale (gsl_vector_complex_float * a, const gsl_complex_float x); +-int gsl_vector_complex_float_add_constant (gsl_vector_complex_float * a, const gsl_complex_float x); +- +-INLINE_DECL gsl_complex_float gsl_vector_complex_float_get (const gsl_vector_complex_float * v, const size_t i); +-INLINE_DECL void gsl_vector_complex_float_set (gsl_vector_complex_float * v, const size_t i, gsl_complex_float z); +-INLINE_DECL gsl_complex_float *gsl_vector_complex_float_ptr (gsl_vector_complex_float * v, const size_t i); +-INLINE_DECL const gsl_complex_float *gsl_vector_complex_float_const_ptr (const gsl_vector_complex_float * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex_float +-gsl_vector_complex_float_get (const gsl_vector_complex_float * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- gsl_complex_float zero = {{0, 0}}; +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); +- } +-#endif +- return *GSL_COMPLEX_FLOAT_AT (v, i); +-} +- +-INLINE_FUN +-void +-gsl_vector_complex_float_set (gsl_vector_complex_float * v, +- const size_t i, gsl_complex_float z) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- *GSL_COMPLEX_FLOAT_AT (v, i) = z; +-} +- +-INLINE_FUN +-gsl_complex_float * +-gsl_vector_complex_float_ptr (gsl_vector_complex_float * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_FLOAT_AT (v, i); +-} +- +-INLINE_FUN +-const gsl_complex_float * +-gsl_vector_complex_float_const_ptr (const gsl_vector_complex_float * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_FLOAT_AT (v, i); +-} +- +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_float.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_FLOAT_H__ +-#define __GSL_BLOCK_FLOAT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_float_struct +-{ +- size_t size; +- float *data; +-}; +- +-typedef struct gsl_block_float_struct gsl_block_float; +- +-gsl_block_float *gsl_block_float_alloc (const size_t n); +-gsl_block_float *gsl_block_float_calloc (const size_t n); +-void gsl_block_float_free (gsl_block_float * b); +- +-int gsl_block_float_fread (FILE * stream, gsl_block_float * b); +-int gsl_block_float_fwrite (FILE * stream, const gsl_block_float * b); +-int gsl_block_float_fscanf (FILE * stream, gsl_block_float * b); +-int gsl_block_float_fprintf (FILE * stream, const gsl_block_float * b, const char *format); +- +-int gsl_block_float_raw_fread (FILE * stream, float * b, const size_t n, const size_t stride); +-int gsl_block_float_raw_fwrite (FILE * stream, const float * b, const size_t n, const size_t stride); +-int gsl_block_float_raw_fscanf (FILE * stream, float * b, const size_t n, const size_t stride); +-int gsl_block_float_raw_fprintf (FILE * stream, const float * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_float_size (const gsl_block_float * b); +-float * gsl_block_float_data (const gsl_block_float * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_miser.h (revision 14079) +@@ -1,97 +0,0 @@ +-/* monte/gsl_monte_miser.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth +- * Copyright (C) 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: MJB */ +- +-#ifndef __GSL_MONTE_MISER_H__ +-#define __GSL_MONTE_MISER_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- size_t min_calls; +- size_t min_calls_per_bisection; +- double dither; +- double estimate_frac; +- double alpha; +- size_t dim; +- int estimate_style; +- int depth; +- int verbose; +- double * x; +- double * xmid; +- double * sigma_l; +- double * sigma_r; +- double * fmax_l; +- double * fmax_r; +- double * fmin_l; +- double * fmin_r; +- double * fsum_l; +- double * fsum_r; +- double * fsum2_l; +- double * fsum2_r; +- size_t * hits_l; +- size_t * hits_r; +-} gsl_monte_miser_state; +- +-int gsl_monte_miser_integrate(gsl_monte_function * f, +- const double xl[], const double xh[], +- size_t dim, size_t calls, +- gsl_rng *r, +- gsl_monte_miser_state* state, +- double *result, double *abserr); +- +-gsl_monte_miser_state* gsl_monte_miser_alloc(size_t dim); +- +-int gsl_monte_miser_init(gsl_monte_miser_state* state); +- +-void gsl_monte_miser_free(gsl_monte_miser_state* state); +- +-typedef struct { +- double estimate_frac; +- size_t min_calls; +- size_t min_calls_per_bisection; +- double alpha; +- double dither; +-} gsl_monte_miser_params; +- +-void gsl_monte_miser_params_get (const gsl_monte_miser_state * state, +- gsl_monte_miser_params * params); +- +-void gsl_monte_miser_params_set (gsl_monte_miser_state * state, +- const gsl_monte_miser_params * params); +- +-__END_DECLS +- +-#endif /* __GSL_MONTE_MISER_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_short.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_SHORT_H__ +-#define __GSL_MATRIX_SHORT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- short * data; +- gsl_block_short * block; +- int owner; +-} gsl_matrix_short; +- +-typedef struct +-{ +- gsl_matrix_short matrix; +-} _gsl_matrix_short_view; +- +-typedef _gsl_matrix_short_view gsl_matrix_short_view; +- +-typedef struct +-{ +- gsl_matrix_short matrix; +-} _gsl_matrix_short_const_view; +- +-typedef const _gsl_matrix_short_const_view gsl_matrix_short_const_view; +- +-/* Allocation */ +- +-gsl_matrix_short * +-gsl_matrix_short_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_short * +-gsl_matrix_short_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_short * +-gsl_matrix_short_alloc_from_block (gsl_block_short * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_short * +-gsl_matrix_short_alloc_from_matrix (gsl_matrix_short * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_short * +-gsl_vector_short_alloc_row_from_matrix (gsl_matrix_short * m, +- const size_t i); +- +-gsl_vector_short * +-gsl_vector_short_alloc_col_from_matrix (gsl_matrix_short * m, +- const size_t j); +- +-void gsl_matrix_short_free (gsl_matrix_short * m); +- +-/* Views */ +- +-_gsl_matrix_short_view +-gsl_matrix_short_submatrix (gsl_matrix_short * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_short_view +-gsl_matrix_short_row (gsl_matrix_short * m, const size_t i); +- +-_gsl_vector_short_view +-gsl_matrix_short_column (gsl_matrix_short * m, const size_t j); +- +-_gsl_vector_short_view +-gsl_matrix_short_diagonal (gsl_matrix_short * m); +- +-_gsl_vector_short_view +-gsl_matrix_short_subdiagonal (gsl_matrix_short * m, const size_t k); +- +-_gsl_vector_short_view +-gsl_matrix_short_superdiagonal (gsl_matrix_short * m, const size_t k); +- +-_gsl_vector_short_view +-gsl_matrix_short_subrow (gsl_matrix_short * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_short_view +-gsl_matrix_short_subcolumn (gsl_matrix_short * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_short_view +-gsl_matrix_short_view_array (short * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_short_view +-gsl_matrix_short_view_array_with_tda (short * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_short_view +-gsl_matrix_short_view_vector (gsl_vector_short * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_short_view +-gsl_matrix_short_view_vector_with_tda (gsl_vector_short * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_short_const_view +-gsl_matrix_short_const_submatrix (const gsl_matrix_short * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_row (const gsl_matrix_short * m, +- const size_t i); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_column (const gsl_matrix_short * m, +- const size_t j); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_diagonal (const gsl_matrix_short * m); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_subdiagonal (const gsl_matrix_short * m, +- const size_t k); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_superdiagonal (const gsl_matrix_short * m, +- const size_t k); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_subrow (const gsl_matrix_short * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_short_const_view +-gsl_matrix_short_const_subcolumn (const gsl_matrix_short * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_short_const_view +-gsl_matrix_short_const_view_array (const short * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_short_const_view +-gsl_matrix_short_const_view_array_with_tda (const short * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_short_const_view +-gsl_matrix_short_const_view_vector (const gsl_vector_short * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_short_const_view +-gsl_matrix_short_const_view_vector_with_tda (const gsl_vector_short * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_short_set_zero (gsl_matrix_short * m); +-void gsl_matrix_short_set_identity (gsl_matrix_short * m); +-void gsl_matrix_short_set_all (gsl_matrix_short * m, short x); +- +-int gsl_matrix_short_fread (FILE * stream, gsl_matrix_short * m) ; +-int gsl_matrix_short_fwrite (FILE * stream, const gsl_matrix_short * m) ; +-int gsl_matrix_short_fscanf (FILE * stream, gsl_matrix_short * m); +-int gsl_matrix_short_fprintf (FILE * stream, const gsl_matrix_short * m, const char * format); +- +-int gsl_matrix_short_memcpy(gsl_matrix_short * dest, const gsl_matrix_short * src); +-int gsl_matrix_short_swap(gsl_matrix_short * m1, gsl_matrix_short * m2); +- +-int gsl_matrix_short_swap_rows(gsl_matrix_short * m, const size_t i, const size_t j); +-int gsl_matrix_short_swap_columns(gsl_matrix_short * m, const size_t i, const size_t j); +-int gsl_matrix_short_swap_rowcol(gsl_matrix_short * m, const size_t i, const size_t j); +-int gsl_matrix_short_transpose (gsl_matrix_short * m); +-int gsl_matrix_short_transpose_memcpy (gsl_matrix_short * dest, const gsl_matrix_short * src); +- +-short gsl_matrix_short_max (const gsl_matrix_short * m); +-short gsl_matrix_short_min (const gsl_matrix_short * m); +-void gsl_matrix_short_minmax (const gsl_matrix_short * m, short * min_out, short * max_out); +- +-void gsl_matrix_short_max_index (const gsl_matrix_short * m, size_t * imax, size_t *jmax); +-void gsl_matrix_short_min_index (const gsl_matrix_short * m, size_t * imin, size_t *jmin); +-void gsl_matrix_short_minmax_index (const gsl_matrix_short * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_short_equal (const gsl_matrix_short * a, const gsl_matrix_short * b); +- +-int gsl_matrix_short_isnull (const gsl_matrix_short * m); +-int gsl_matrix_short_ispos (const gsl_matrix_short * m); +-int gsl_matrix_short_isneg (const gsl_matrix_short * m); +-int gsl_matrix_short_isnonneg (const gsl_matrix_short * m); +- +-int gsl_matrix_short_add (gsl_matrix_short * a, const gsl_matrix_short * b); +-int gsl_matrix_short_sub (gsl_matrix_short * a, const gsl_matrix_short * b); +-int gsl_matrix_short_mul_elements (gsl_matrix_short * a, const gsl_matrix_short * b); +-int gsl_matrix_short_div_elements (gsl_matrix_short * a, const gsl_matrix_short * b); +-int gsl_matrix_short_scale (gsl_matrix_short * a, const double x); +-int gsl_matrix_short_add_constant (gsl_matrix_short * a, const double x); +-int gsl_matrix_short_add_diagonal (gsl_matrix_short * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_short_get_row(gsl_vector_short * v, const gsl_matrix_short * m, const size_t i); +-int gsl_matrix_short_get_col(gsl_vector_short * v, const gsl_matrix_short * m, const size_t j); +-int gsl_matrix_short_set_row(gsl_matrix_short * m, const size_t i, const gsl_vector_short * v); +-int gsl_matrix_short_set_col(gsl_matrix_short * m, const size_t j, const gsl_vector_short * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL short gsl_matrix_short_get(const gsl_matrix_short * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_short_set(gsl_matrix_short * m, const size_t i, const size_t j, const short x); +-INLINE_DECL short * gsl_matrix_short_ptr(gsl_matrix_short * m, const size_t i, const size_t j); +-INLINE_DECL const short * gsl_matrix_short_const_ptr(const gsl_matrix_short * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-short +-gsl_matrix_short_get(const gsl_matrix_short * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_short_set(gsl_matrix_short * m, const size_t i, const size_t j, const short x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-short * +-gsl_matrix_short_ptr(gsl_matrix_short * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (short *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const short * +-gsl_matrix_short_const_ptr(const gsl_matrix_short * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const short *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_int.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_INT_H__ +-#define __GSL_SORT_VECTOR_INT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_int (gsl_vector_int * v); +-int gsl_sort_vector_int_index (gsl_permutation * p, const gsl_vector_int * v); +- +-int gsl_sort_vector_int_smallest (int * dest, const size_t k, const gsl_vector_int * v); +-int gsl_sort_vector_int_largest (int * dest, const size_t k, const gsl_vector_int * v); +- +-int gsl_sort_vector_int_smallest_index (size_t * p, const size_t k, const gsl_vector_int * v); +-int gsl_sort_vector_int_largest_index (size_t * p, const size_t k, const gsl_vector_int * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_double.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_DOUBLE_H__ +-#define __GSL_BLOCK_DOUBLE_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_struct +-{ +- size_t size; +- double *data; +-}; +- +-typedef struct gsl_block_struct gsl_block; +- +-gsl_block *gsl_block_alloc (const size_t n); +-gsl_block *gsl_block_calloc (const size_t n); +-void gsl_block_free (gsl_block * b); +- +-int gsl_block_fread (FILE * stream, gsl_block * b); +-int gsl_block_fwrite (FILE * stream, const gsl_block * b); +-int gsl_block_fscanf (FILE * stream, gsl_block * b); +-int gsl_block_fprintf (FILE * stream, const gsl_block * b, const char *format); +- +-int gsl_block_raw_fread (FILE * stream, double * b, const size_t n, const size_t stride); +-int gsl_block_raw_fwrite (FILE * stream, const double * b, const size_t n, const size_t stride); +-int gsl_block_raw_fscanf (FILE * stream, double * b, const size_t n, const size_t stride); +-int gsl_block_raw_fprintf (FILE * stream, const double * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_size (const gsl_block * b); +-double * gsl_block_data (const gsl_block * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const.h (revision 14079) +@@ -1,31 +0,0 @@ +-/* const/gsl_const.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST__ +-#define __GSL_CONST__ +- +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_CONST__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_minmax.h (revision 14079) +@@ -1,102 +0,0 @@ +-/* gsl_minmax.h +- * +- * Copyright (C) 2008 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MINMAX_H__ +-#define __GSL_MINMAX_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Define MAX and MIN macros/functions if they don't exist. */ +- +-/* plain old macros for general use */ +-#define GSL_MAX(a,b) ((a) > (b) ? (a) : (b)) +-#define GSL_MIN(a,b) ((a) < (b) ? (a) : (b)) +- +-/* function versions of the above, in case they are needed */ +-double gsl_max (double a, double b); +-double gsl_min (double a, double b); +- +-/* inline-friendly strongly typed versions */ +-#ifdef HAVE_INLINE +- +-INLINE_FUN int GSL_MAX_INT (int a, int b); +-INLINE_FUN int GSL_MIN_INT (int a, int b); +-INLINE_FUN double GSL_MAX_DBL (double a, double b); +-INLINE_FUN double GSL_MIN_DBL (double a, double b); +-INLINE_FUN long double GSL_MAX_LDBL (long double a, long double b); +-INLINE_FUN long double GSL_MIN_LDBL (long double a, long double b); +- +-INLINE_FUN int +-GSL_MAX_INT (int a, int b) +-{ +- return GSL_MAX (a, b); +-} +- +-INLINE_FUN int +-GSL_MIN_INT (int a, int b) +-{ +- return GSL_MIN (a, b); +-} +- +-INLINE_FUN double +-GSL_MAX_DBL (double a, double b) +-{ +- return GSL_MAX (a, b); +-} +- +-INLINE_FUN double +-GSL_MIN_DBL (double a, double b) +-{ +- return GSL_MIN (a, b); +-} +- +-INLINE_FUN long double +-GSL_MAX_LDBL (long double a, long double b) +-{ +- return GSL_MAX (a, b); +-} +- +-INLINE_FUN long double +-GSL_MIN_LDBL (long double a, long double b) +-{ +- return GSL_MIN (a, b); +-} +-#else +-#define GSL_MAX_INT(a,b) GSL_MAX(a,b) +-#define GSL_MIN_INT(a,b) GSL_MIN(a,b) +-#define GSL_MAX_DBL(a,b) GSL_MAX(a,b) +-#define GSL_MIN_DBL(a,b) GSL_MIN(a,b) +-#define GSL_MAX_LDBL(a,b) GSL_MAX(a,b) +-#define GSL_MIN_LDBL(a,b) GSL_MIN(a,b) +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uint.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_UINT_H__ +-#define __GSL_STATISTICS_UINT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_uint_mean (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_variance (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_sd (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_variance_with_fixed_mean (const unsigned int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uint_sd_with_fixed_mean (const unsigned int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uint_tss (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_tss_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_uint_absdev (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_skew (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_kurtosis (const unsigned int data[], const size_t stride, const size_t n); +-double gsl_stats_uint_lag1_autocorrelation (const unsigned int data[], const size_t stride, const size_t n); +- +-double gsl_stats_uint_covariance (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n); +-double gsl_stats_uint_correlation (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_uint_variance_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uint_sd_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uint_absdev_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uint_skew_m_sd (const unsigned int data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_uint_kurtosis_m_sd (const unsigned int data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_uint_lag1_autocorrelation_m (const unsigned int data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_uint_covariance_m (const unsigned int data1[], const size_t stride1,const unsigned int data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_uint_pvariance (const unsigned int data1[], const size_t stride1, const size_t n1, const unsigned int data2[], const size_t stride2, const size_t n2); +-double gsl_stats_uint_ttest (const unsigned int data1[], const size_t stride1, const size_t n1, const unsigned int data2[], const size_t stride2, const size_t n2); +- +-unsigned int gsl_stats_uint_max (const unsigned int data[], const size_t stride, const size_t n); +-unsigned int gsl_stats_uint_min (const unsigned int data[], const size_t stride, const size_t n); +-void gsl_stats_uint_minmax (unsigned int * min, unsigned int * max, const unsigned int data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_uint_max_index (const unsigned int data[], const size_t stride, const size_t n); +-size_t gsl_stats_uint_min_index (const unsigned int data[], const size_t stride, const size_t n); +-void gsl_stats_uint_minmax_index (size_t * min_index, size_t * max_index, const unsigned int data[], const size_t stride, const size_t n); +- +-double gsl_stats_uint_median_from_sorted_data (const unsigned int sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_uint_quantile_from_sorted_data (const unsigned int sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long_double.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_LONG_DOUBLE_H__ +-#define __GSL_PERMUTE_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_long_double (const size_t * p, long double * data, const size_t stride, const size_t n); +-int gsl_permute_long_double_inverse (const size_t * p, long double * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uchar.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_UCHAR_H__ +-#define __GSL_SORT_VECTOR_UCHAR_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_uchar (gsl_vector_uchar * v); +-int gsl_sort_vector_uchar_index (gsl_permutation * p, const gsl_vector_uchar * v); +- +-int gsl_sort_vector_uchar_smallest (unsigned char * dest, const size_t k, const gsl_vector_uchar * v); +-int gsl_sort_vector_uchar_largest (unsigned char * dest, const size_t k, const gsl_vector_uchar * v); +- +-int gsl_sort_vector_uchar_smallest_index (size_t * p, const size_t k, const gsl_vector_uchar * v); +-int gsl_sort_vector_uchar_largest_index (size_t * p, const size_t k, const gsl_vector_uchar * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_DOUBLE_H__ +-#define __GSL_PERMUTE_VECTOR_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector (const gsl_permutation * p, gsl_vector * v); +-int gsl_permute_vector_inverse (const gsl_permutation * p, gsl_vector * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_expint.h (revision 14079) +@@ -1,167 +0,0 @@ +-/* specfunc/gsl_sf_expint.h +- * +- * Copyright (C) 2007 Brian Gough +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_EXPINT_H__ +-#define __GSL_SF_EXPINT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* E_1(x) := Re[ Integrate[ Exp[-xt]/t, {t,1,Infinity}] ] +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_E1_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_E1(const double x); +- +- +-/* E_2(x) := Re[ Integrate[ Exp[-xt]/t^2, {t,1,Infinity}] ] +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_E2_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_E2(const double x); +- +- +-/* E_n(x) := Re[ Integrate[ Exp[-xt]/t^n, {t,1,Infinity}] ] +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_En_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_expint_En(const int n, const double x); +- +- +-/* E_1_scaled(x) := exp(x) E_1(x) +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_E1_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_E1_scaled(const double x); +- +- +-/* E_2_scaled(x) := exp(x) E_2(x) +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_E2_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_E2_scaled(const double x); +- +-/* E_n_scaled(x) := exp(x) E_n(x) +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_En_scaled_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_expint_En_scaled(const int n, const double x); +- +- +-/* Ei(x) := - PV Integrate[ Exp[-t]/t, {t,-x,Infinity}] +- * := PV Integrate[ Exp[t]/t, {t,-Infinity,x}] +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_Ei_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_Ei(const double x); +- +- +-/* Ei_scaled(x) := exp(-x) Ei(x) +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_expint_Ei_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_Ei_scaled(const double x); +- +- +-/* Shi(x) := Integrate[ Sinh[t]/t, {t,0,x}] +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_Shi_e(const double x, gsl_sf_result * result); +-double gsl_sf_Shi(const double x); +- +- +-/* Chi(x) := Re[ M_EULER + log(x) + Integrate[(Cosh[t]-1)/t, {t,0,x}] ] +- * +- * x != 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_Chi_e(const double x, gsl_sf_result * result); +-double gsl_sf_Chi(const double x); +- +- +-/* Ei_3(x) := Integral[ Exp[-t^3], {t,0,x}] +- * +- * x >= 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_expint_3_e(const double x, gsl_sf_result * result); +-double gsl_sf_expint_3(double x); +- +- +-/* Si(x) := Integrate[ Sin[t]/t, {t,0,x}] +- * +- * exceptions: none +- */ +-int gsl_sf_Si_e(const double x, gsl_sf_result * result); +-double gsl_sf_Si(const double x); +- +- +-/* Ci(x) := -Integrate[ Cos[t]/t, {t,x,Infinity}] +- * +- * x > 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_Ci_e(const double x, gsl_sf_result * result); +-double gsl_sf_Ci(const double x); +- +- +-/* AtanInt(x) := Integral[ Arctan[t]/t, {t,0,x}] +- * +- * +- * exceptions: +- */ +-int gsl_sf_atanint_e(const double x, gsl_sf_result * result); +-double gsl_sf_atanint(const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_EXPINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_short.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_SHORT_H__ +-#define __GSL_PERMUTE_SHORT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_short (const size_t * p, short * data, const size_t stride, const size_t n); +-int gsl_permute_short_inverse (const size_t * p, short * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex.h (revision 14079) +@@ -1,86 +0,0 @@ +-/* fft/gsl_fft_halfcomplex.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_HALFCOMPLEX_H__ +-#define __GSL_FFT_HALFCOMPLEX_H__ +- +-#include +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_fft_halfcomplex_radix2_backward (double data[], const size_t stride, const size_t n); +-int gsl_fft_halfcomplex_radix2_inverse (double data[], const size_t stride, const size_t n); +-int gsl_fft_halfcomplex_radix2_transform (double data[], const size_t stride, const size_t n); +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex *twiddle[64]; +- gsl_complex *trig; +- } +-gsl_fft_halfcomplex_wavetable; +- +-gsl_fft_halfcomplex_wavetable * gsl_fft_halfcomplex_wavetable_alloc (size_t n); +- +-void +-gsl_fft_halfcomplex_wavetable_free (gsl_fft_halfcomplex_wavetable * wavetable); +- +- +-int gsl_fft_halfcomplex_backward (double data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable * wavetable, +- gsl_fft_real_workspace * work); +- +-int gsl_fft_halfcomplex_inverse (double data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable * wavetable, +- gsl_fft_real_workspace * work); +- +-int gsl_fft_halfcomplex_transform (double data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable * wavetable, +- gsl_fft_real_workspace * work); +- +-int +-gsl_fft_halfcomplex_unpack (const double halfcomplex_coefficient[], +- double complex_coefficient[], +- const size_t stride, const size_t n); +- +-int +-gsl_fft_halfcomplex_radix2_unpack (const double halfcomplex_coefficient[], +- double complex_coefficient[], +- const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_HALFCOMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_char.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_CHAR_H__ +-#define __GSL_SORT_VECTOR_CHAR_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_char (gsl_vector_char * v); +-int gsl_sort_vector_char_index (gsl_permutation * p, const gsl_vector_char * v); +- +-int gsl_sort_vector_char_smallest (char * dest, const size_t k, const gsl_vector_char * v); +-int gsl_sort_vector_char_largest (char * dest, const size_t k, const gsl_vector_char * v); +- +-int gsl_sort_vector_char_smallest_index (size_t * p, const size_t k, const gsl_vector_char * v); +-int gsl_sort_vector_char_largest_index (size_t * p, const size_t k, const gsl_vector_char * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex.h (revision 14079) +@@ -1,103 +0,0 @@ +-/* complex/gsl_complex.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_COMPLEX_H__ +-#define __GSL_COMPLEX_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* two consecutive built-in types as a complex number */ +-typedef double * gsl_complex_packed ; +-typedef float * gsl_complex_packed_float ; +-typedef long double * gsl_complex_packed_long_double ; +- +-typedef const double * gsl_const_complex_packed ; +-typedef const float * gsl_const_complex_packed_float ; +-typedef const long double * gsl_const_complex_packed_long_double ; +- +- +-/* 2N consecutive built-in types as N complex numbers */ +-typedef double * gsl_complex_packed_array ; +-typedef float * gsl_complex_packed_array_float ; +-typedef long double * gsl_complex_packed_array_long_double ; +- +-typedef const double * gsl_const_complex_packed_array ; +-typedef const float * gsl_const_complex_packed_array_float ; +-typedef const long double * gsl_const_complex_packed_array_long_double ; +- +- +-/* Yes... this seems weird. Trust us. The point is just that +- sometimes you want to make it obvious that something is +- an output value. The fact that it lacks a 'const' may not +- be enough of a clue for people in some contexts. +- */ +-typedef double * gsl_complex_packed_ptr ; +-typedef float * gsl_complex_packed_float_ptr ; +-typedef long double * gsl_complex_packed_long_double_ptr ; +- +-typedef const double * gsl_const_complex_packed_ptr ; +-typedef const float * gsl_const_complex_packed_float_ptr ; +-typedef const long double * gsl_const_complex_packed_long_double_ptr ; +- +- +-typedef struct +- { +- long double dat[2]; +- } +-gsl_complex_long_double; +- +-typedef struct +- { +- double dat[2]; +- } +-gsl_complex; +- +-typedef struct +- { +- float dat[2]; +- } +-gsl_complex_float; +- +-#define GSL_REAL(z) ((z).dat[0]) +-#define GSL_IMAG(z) ((z).dat[1]) +-#define GSL_COMPLEX_P(zp) ((zp)->dat) +-#define GSL_COMPLEX_P_REAL(zp) ((zp)->dat[0]) +-#define GSL_COMPLEX_P_IMAG(zp) ((zp)->dat[1]) +-#define GSL_COMPLEX_EQ(z1,z2) (((z1).dat[0] == (z2).dat[0]) && ((z1).dat[1] == (z2).dat[1])) +- +-#define GSL_SET_COMPLEX(zp,x,y) do {(zp)->dat[0]=(x); (zp)->dat[1]=(y);} while(0) +-#define GSL_SET_REAL(zp,x) do {(zp)->dat[0]=(x);} while(0) +-#define GSL_SET_IMAG(zp,y) do {(zp)->dat[1]=(y);} while(0) +- +-#define GSL_SET_COMPLEX_PACKED(zp,n,x,y) do {*((zp)+2*(n))=(x); *((zp)+(2*(n)+1))=(y);} while(0) +- +-__END_DECLS +- +-#endif /* __GSL_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_log.h (revision 14079) +@@ -1,82 +0,0 @@ +-/* specfunc/gsl_sf_log.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_LOG_H__ +-#define __GSL_SF_LOG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Provide a logarithm function with GSL semantics. +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_log_e(const double x, gsl_sf_result * result); +-double gsl_sf_log(const double x); +- +- +-/* Log(|x|) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_log_abs_e(const double x, gsl_sf_result * result); +-double gsl_sf_log_abs(const double x); +- +- +-/* Complex Logarithm +- * exp(lnr + I theta) = zr + I zi +- * Returns argument in [-pi,pi]. +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_complex_log_e(const double zr, const double zi, gsl_sf_result * lnr, gsl_sf_result * theta); +- +- +-/* Log(1 + x) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_log_1plusx_e(const double x, gsl_sf_result * result); +-double gsl_sf_log_1plusx(const double x); +- +- +-/* Log(1 + x) - x +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_log_1plusx_mx_e(const double x, gsl_sf_result * result); +-double gsl_sf_log_1plusx_mx(const double x); +- +-__END_DECLS +- +-#endif /* __GSL_SF_LOG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_LONG_H__ +-#define __GSL_STATISTICS_LONG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_long_mean (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_variance (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_sd (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_variance_with_fixed_mean (const long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_sd_with_fixed_mean (const long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_tss (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_tss_m (const long data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_long_absdev (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_skew (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_kurtosis (const long data[], const size_t stride, const size_t n); +-double gsl_stats_long_lag1_autocorrelation (const long data[], const size_t stride, const size_t n); +- +-double gsl_stats_long_covariance (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n); +-double gsl_stats_long_correlation (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_long_variance_m (const long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_sd_m (const long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_absdev_m (const long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_skew_m_sd (const long data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_long_kurtosis_m_sd (const long data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_long_lag1_autocorrelation_m (const long data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_long_covariance_m (const long data1[], const size_t stride1,const long data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_long_pvariance (const long data1[], const size_t stride1, const size_t n1, const long data2[], const size_t stride2, const size_t n2); +-double gsl_stats_long_ttest (const long data1[], const size_t stride1, const size_t n1, const long data2[], const size_t stride2, const size_t n2); +- +-long gsl_stats_long_max (const long data[], const size_t stride, const size_t n); +-long gsl_stats_long_min (const long data[], const size_t stride, const size_t n); +-void gsl_stats_long_minmax (long * min, long * max, const long data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_long_max_index (const long data[], const size_t stride, const size_t n); +-size_t gsl_stats_long_min_index (const long data[], const size_t stride, const size_t n); +-void gsl_stats_long_minmax_index (size_t * min_index, size_t * max_index, const long data[], const size_t stride, const size_t n); +- +-double gsl_stats_long_median_from_sorted_data (const long sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_long_quantile_from_sorted_data (const long sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_double.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_complex_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_COMPLEX_DOUBLE_H__ +-#define __GSL_BLOCK_COMPLEX_DOUBLE_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_complex_struct +-{ +- size_t size; +- double *data; +-}; +- +-typedef struct gsl_block_complex_struct gsl_block_complex; +- +-gsl_block_complex *gsl_block_complex_alloc (const size_t n); +-gsl_block_complex *gsl_block_complex_calloc (const size_t n); +-void gsl_block_complex_free (gsl_block_complex * b); +- +-int gsl_block_complex_fread (FILE * stream, gsl_block_complex * b); +-int gsl_block_complex_fwrite (FILE * stream, const gsl_block_complex * b); +-int gsl_block_complex_fscanf (FILE * stream, gsl_block_complex * b); +-int gsl_block_complex_fprintf (FILE * stream, const gsl_block_complex * b, const char *format); +- +-int gsl_block_complex_raw_fread (FILE * stream, double * b, const size_t n, const size_t stride); +-int gsl_block_complex_raw_fwrite (FILE * stream, const double * b, const size_t n, const size_t stride); +-int gsl_block_complex_raw_fscanf (FILE * stream, double * b, const size_t n, const size_t stride); +-int gsl_block_complex_raw_fprintf (FILE * stream, const double * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_complex_size (const gsl_block_complex * b); +-double * gsl_block_complex_data (const gsl_block_complex * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ +-#define __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_long_double (const gsl_permutation * p, gsl_vector_long_double * v); +-int gsl_permute_vector_long_double_inverse (const gsl_permutation * p, gsl_vector_long_double * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_int.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_INT_H__ +-#define __GSL_VECTOR_INT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- int *data; +- gsl_block_int *block; +- int owner; +-} +-gsl_vector_int; +- +-typedef struct +-{ +- gsl_vector_int vector; +-} _gsl_vector_int_view; +- +-typedef _gsl_vector_int_view gsl_vector_int_view; +- +-typedef struct +-{ +- gsl_vector_int vector; +-} _gsl_vector_int_const_view; +- +-typedef const _gsl_vector_int_const_view gsl_vector_int_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_int *gsl_vector_int_alloc (const size_t n); +-gsl_vector_int *gsl_vector_int_calloc (const size_t n); +- +-gsl_vector_int *gsl_vector_int_alloc_from_block (gsl_block_int * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_int *gsl_vector_int_alloc_from_vector (gsl_vector_int * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_int_free (gsl_vector_int * v); +- +-/* Views */ +- +-_gsl_vector_int_view +-gsl_vector_int_view_array (int *v, size_t n); +- +-_gsl_vector_int_view +-gsl_vector_int_view_array_with_stride (int *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_int_const_view +-gsl_vector_int_const_view_array (const int *v, size_t n); +- +-_gsl_vector_int_const_view +-gsl_vector_int_const_view_array_with_stride (const int *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_int_view +-gsl_vector_int_subvector (gsl_vector_int *v, +- size_t i, +- size_t n); +- +-_gsl_vector_int_view +-gsl_vector_int_subvector_with_stride (gsl_vector_int *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_int_const_view +-gsl_vector_int_const_subvector (const gsl_vector_int *v, +- size_t i, +- size_t n); +- +-_gsl_vector_int_const_view +-gsl_vector_int_const_subvector_with_stride (const gsl_vector_int *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_int_set_zero (gsl_vector_int * v); +-void gsl_vector_int_set_all (gsl_vector_int * v, int x); +-int gsl_vector_int_set_basis (gsl_vector_int * v, size_t i); +- +-int gsl_vector_int_fread (FILE * stream, gsl_vector_int * v); +-int gsl_vector_int_fwrite (FILE * stream, const gsl_vector_int * v); +-int gsl_vector_int_fscanf (FILE * stream, gsl_vector_int * v); +-int gsl_vector_int_fprintf (FILE * stream, const gsl_vector_int * v, +- const char *format); +- +-int gsl_vector_int_memcpy (gsl_vector_int * dest, const gsl_vector_int * src); +- +-int gsl_vector_int_reverse (gsl_vector_int * v); +- +-int gsl_vector_int_swap (gsl_vector_int * v, gsl_vector_int * w); +-int gsl_vector_int_swap_elements (gsl_vector_int * v, const size_t i, const size_t j); +- +-int gsl_vector_int_max (const gsl_vector_int * v); +-int gsl_vector_int_min (const gsl_vector_int * v); +-void gsl_vector_int_minmax (const gsl_vector_int * v, int * min_out, int * max_out); +- +-size_t gsl_vector_int_max_index (const gsl_vector_int * v); +-size_t gsl_vector_int_min_index (const gsl_vector_int * v); +-void gsl_vector_int_minmax_index (const gsl_vector_int * v, size_t * imin, size_t * imax); +- +-int gsl_vector_int_add (gsl_vector_int * a, const gsl_vector_int * b); +-int gsl_vector_int_sub (gsl_vector_int * a, const gsl_vector_int * b); +-int gsl_vector_int_mul (gsl_vector_int * a, const gsl_vector_int * b); +-int gsl_vector_int_div (gsl_vector_int * a, const gsl_vector_int * b); +-int gsl_vector_int_scale (gsl_vector_int * a, const double x); +-int gsl_vector_int_add_constant (gsl_vector_int * a, const double x); +- +-int gsl_vector_int_equal (const gsl_vector_int * u, +- const gsl_vector_int * v); +- +-int gsl_vector_int_isnull (const gsl_vector_int * v); +-int gsl_vector_int_ispos (const gsl_vector_int * v); +-int gsl_vector_int_isneg (const gsl_vector_int * v); +-int gsl_vector_int_isnonneg (const gsl_vector_int * v); +- +-INLINE_DECL int gsl_vector_int_get (const gsl_vector_int * v, const size_t i); +-INLINE_DECL void gsl_vector_int_set (gsl_vector_int * v, const size_t i, int x); +-INLINE_DECL int * gsl_vector_int_ptr (gsl_vector_int * v, const size_t i); +-INLINE_DECL const int * gsl_vector_int_const_ptr (const gsl_vector_int * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-int +-gsl_vector_int_get (const gsl_vector_int * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_int_set (gsl_vector_int * v, const size_t i, int x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-int * +-gsl_vector_int_ptr (gsl_vector_int * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (int *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const int * +-gsl_vector_int_const_ptr (const gsl_vector_int * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const int *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_INT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_inline.h (revision 14079) +@@ -1,67 +0,0 @@ +-/* gsl_inline.h +- * +- * Copyright (C) 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_INLINE_H__ +-#define __GSL_INLINE_H__ +- +-/* In recent versiions of GCC, the inline keyword has two different +- forms: GNU and C99. +- +- In GNU mode we can use 'extern inline' to make inline functions +- work like macros. The function is only inlined--it is never output +- as a definition in an object file. +- +- In the new C99 mode 'extern inline' has a different meaning--it +- causes the definition of the function to be output in each object +- file where it is used. This will result in multiple-definition +- errors on linking. The 'inline' keyword on its own (without +- extern) has the same behavior as the original GNU 'extern inline'. +- +- The C99 style is the default with -std=c99 in GCC 4.3. +- +- This header file allows either form of inline to be used by +- redefining the macros INLINE_DECL and INLINE_FUN. These are used +- in the public header files as +- +- INLINE_DECL double gsl_foo (double x); +- #ifdef HAVE_INLINE +- INLINE_FUN double gsl_foo (double x) { return x+1.0; } ; +- #endif +- +-*/ +- +-#ifdef HAVE_INLINE +-# if defined(__GNUC_STDC_INLINE__) || defined(GSL_C99_INLINE) || defined(HAVE_C99_INLINE) +-# define INLINE_DECL inline /* use C99 inline */ +-# define INLINE_FUN inline +-# else +-# define INLINE_DECL /* use GNU extern inline */ +-# define INLINE_FUN extern inline +-# endif +-#else +-# define INLINE_DECL /* */ +-#endif +- +-/* Range checking conditions in headers do not require any run-time +- tests of the global variable gsl_check_range. They are enabled or +- disabled in user code at compile time with GSL_RANGE_CHECK macro. +- See also build.h. */ +-#define GSL_RANGE_COND(x) (x) +- +-#endif /* __GSL_INLINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_int.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_INT_H__ +-#define __GSL_MATRIX_INT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- int * data; +- gsl_block_int * block; +- int owner; +-} gsl_matrix_int; +- +-typedef struct +-{ +- gsl_matrix_int matrix; +-} _gsl_matrix_int_view; +- +-typedef _gsl_matrix_int_view gsl_matrix_int_view; +- +-typedef struct +-{ +- gsl_matrix_int matrix; +-} _gsl_matrix_int_const_view; +- +-typedef const _gsl_matrix_int_const_view gsl_matrix_int_const_view; +- +-/* Allocation */ +- +-gsl_matrix_int * +-gsl_matrix_int_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_int * +-gsl_matrix_int_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_int * +-gsl_matrix_int_alloc_from_block (gsl_block_int * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_int * +-gsl_matrix_int_alloc_from_matrix (gsl_matrix_int * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_int * +-gsl_vector_int_alloc_row_from_matrix (gsl_matrix_int * m, +- const size_t i); +- +-gsl_vector_int * +-gsl_vector_int_alloc_col_from_matrix (gsl_matrix_int * m, +- const size_t j); +- +-void gsl_matrix_int_free (gsl_matrix_int * m); +- +-/* Views */ +- +-_gsl_matrix_int_view +-gsl_matrix_int_submatrix (gsl_matrix_int * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_int_view +-gsl_matrix_int_row (gsl_matrix_int * m, const size_t i); +- +-_gsl_vector_int_view +-gsl_matrix_int_column (gsl_matrix_int * m, const size_t j); +- +-_gsl_vector_int_view +-gsl_matrix_int_diagonal (gsl_matrix_int * m); +- +-_gsl_vector_int_view +-gsl_matrix_int_subdiagonal (gsl_matrix_int * m, const size_t k); +- +-_gsl_vector_int_view +-gsl_matrix_int_superdiagonal (gsl_matrix_int * m, const size_t k); +- +-_gsl_vector_int_view +-gsl_matrix_int_subrow (gsl_matrix_int * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_int_view +-gsl_matrix_int_subcolumn (gsl_matrix_int * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_int_view +-gsl_matrix_int_view_array (int * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_int_view +-gsl_matrix_int_view_array_with_tda (int * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_int_view +-gsl_matrix_int_view_vector (gsl_vector_int * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_int_view +-gsl_matrix_int_view_vector_with_tda (gsl_vector_int * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_int_const_view +-gsl_matrix_int_const_submatrix (const gsl_matrix_int * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_row (const gsl_matrix_int * m, +- const size_t i); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_column (const gsl_matrix_int * m, +- const size_t j); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_diagonal (const gsl_matrix_int * m); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_subdiagonal (const gsl_matrix_int * m, +- const size_t k); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_superdiagonal (const gsl_matrix_int * m, +- const size_t k); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_subrow (const gsl_matrix_int * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_int_const_view +-gsl_matrix_int_const_subcolumn (const gsl_matrix_int * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_int_const_view +-gsl_matrix_int_const_view_array (const int * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_int_const_view +-gsl_matrix_int_const_view_array_with_tda (const int * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_int_const_view +-gsl_matrix_int_const_view_vector (const gsl_vector_int * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_int_const_view +-gsl_matrix_int_const_view_vector_with_tda (const gsl_vector_int * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_int_set_zero (gsl_matrix_int * m); +-void gsl_matrix_int_set_identity (gsl_matrix_int * m); +-void gsl_matrix_int_set_all (gsl_matrix_int * m, int x); +- +-int gsl_matrix_int_fread (FILE * stream, gsl_matrix_int * m) ; +-int gsl_matrix_int_fwrite (FILE * stream, const gsl_matrix_int * m) ; +-int gsl_matrix_int_fscanf (FILE * stream, gsl_matrix_int * m); +-int gsl_matrix_int_fprintf (FILE * stream, const gsl_matrix_int * m, const char * format); +- +-int gsl_matrix_int_memcpy(gsl_matrix_int * dest, const gsl_matrix_int * src); +-int gsl_matrix_int_swap(gsl_matrix_int * m1, gsl_matrix_int * m2); +- +-int gsl_matrix_int_swap_rows(gsl_matrix_int * m, const size_t i, const size_t j); +-int gsl_matrix_int_swap_columns(gsl_matrix_int * m, const size_t i, const size_t j); +-int gsl_matrix_int_swap_rowcol(gsl_matrix_int * m, const size_t i, const size_t j); +-int gsl_matrix_int_transpose (gsl_matrix_int * m); +-int gsl_matrix_int_transpose_memcpy (gsl_matrix_int * dest, const gsl_matrix_int * src); +- +-int gsl_matrix_int_max (const gsl_matrix_int * m); +-int gsl_matrix_int_min (const gsl_matrix_int * m); +-void gsl_matrix_int_minmax (const gsl_matrix_int * m, int * min_out, int * max_out); +- +-void gsl_matrix_int_max_index (const gsl_matrix_int * m, size_t * imax, size_t *jmax); +-void gsl_matrix_int_min_index (const gsl_matrix_int * m, size_t * imin, size_t *jmin); +-void gsl_matrix_int_minmax_index (const gsl_matrix_int * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_int_equal (const gsl_matrix_int * a, const gsl_matrix_int * b); +- +-int gsl_matrix_int_isnull (const gsl_matrix_int * m); +-int gsl_matrix_int_ispos (const gsl_matrix_int * m); +-int gsl_matrix_int_isneg (const gsl_matrix_int * m); +-int gsl_matrix_int_isnonneg (const gsl_matrix_int * m); +- +-int gsl_matrix_int_add (gsl_matrix_int * a, const gsl_matrix_int * b); +-int gsl_matrix_int_sub (gsl_matrix_int * a, const gsl_matrix_int * b); +-int gsl_matrix_int_mul_elements (gsl_matrix_int * a, const gsl_matrix_int * b); +-int gsl_matrix_int_div_elements (gsl_matrix_int * a, const gsl_matrix_int * b); +-int gsl_matrix_int_scale (gsl_matrix_int * a, const double x); +-int gsl_matrix_int_add_constant (gsl_matrix_int * a, const double x); +-int gsl_matrix_int_add_diagonal (gsl_matrix_int * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_int_get_row(gsl_vector_int * v, const gsl_matrix_int * m, const size_t i); +-int gsl_matrix_int_get_col(gsl_vector_int * v, const gsl_matrix_int * m, const size_t j); +-int gsl_matrix_int_set_row(gsl_matrix_int * m, const size_t i, const gsl_vector_int * v); +-int gsl_matrix_int_set_col(gsl_matrix_int * m, const size_t j, const gsl_vector_int * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL int gsl_matrix_int_get(const gsl_matrix_int * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_int_set(gsl_matrix_int * m, const size_t i, const size_t j, const int x); +-INLINE_DECL int * gsl_matrix_int_ptr(gsl_matrix_int * m, const size_t i, const size_t j); +-INLINE_DECL const int * gsl_matrix_int_const_ptr(const gsl_matrix_int * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-int +-gsl_matrix_int_get(const gsl_matrix_int * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_int_set(gsl_matrix_int * m, const size_t i, const size_t j, const int x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-int * +-gsl_matrix_int_ptr(gsl_matrix_int * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (int *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const int * +-gsl_matrix_int_const_ptr(const gsl_matrix_int * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const int *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_float.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ +-#define __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_complex_float (const gsl_permutation * p, gsl_vector_complex_float * v); +-int gsl_permute_vector_complex_float_inverse (const gsl_permutation * p, gsl_vector_complex_float * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dht.h (revision 14079) +@@ -1,87 +0,0 @@ +-/* dht/gsl_dht.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman +- */ +-#ifndef __GSL_DHT_H__ +-#define __GSL_DHT_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-struct gsl_dht_struct { +- size_t size; /* size of the sample arrays to be transformed */ +- double nu; /* Bessel function order */ +- double xmax; /* the upper limit to the x-sampling domain */ +- double kmax; /* the upper limit to the k-sampling domain */ +- double * j; /* array of computed J_nu zeros, j_{nu,s} = j[s] */ +- double * Jjj; /* transform numerator, J_nu(j_i j_m / j_N) */ +- double * J2; /* transform denominator, J_{nu+1}^2(j_m) */ +-}; +-typedef struct gsl_dht_struct gsl_dht; +- +- +-/* Create a new transform object for a given size +- * sampling array on the domain [0, xmax]. +- */ +-gsl_dht * gsl_dht_alloc(size_t size); +-gsl_dht * gsl_dht_new(size_t size, double nu, double xmax); +- +-/* Recalculate a transform object for given values of nu, xmax. +- * You cannot change the size of the object since the internal +- * allocation is reused. +- */ +-int gsl_dht_init(gsl_dht * t, double nu, double xmax); +- +-/* The n'th computed x sample point for a given transform. +- * 0 <= n <= size-1 +- */ +-double gsl_dht_x_sample(const gsl_dht * t, int n); +- +- +-/* The n'th computed k sample point for a given transform. +- * 0 <= n <= size-1 +- */ +-double gsl_dht_k_sample(const gsl_dht * t, int n); +- +- +-/* Free a transform object. +- */ +-void gsl_dht_free(gsl_dht * t); +- +- +-/* Perform a transform on a sampled array. +- * f_in[0] ... f_in[size-1] and similarly for f_out[] +- */ +-int gsl_dht_apply(const gsl_dht * t, double * f_in, double * f_out); +- +- +-__END_DECLS +- +-#endif /* __GSL_DHT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte.h (revision 14079) +@@ -1,55 +0,0 @@ +-/* monte/gsl_monte.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Some things common to all the Monte-Carlo implementations */ +-/* Author: MJB */ +- +-#ifndef __GSL_MONTE_H__ +-#define __GSL_MONTE_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Hide the function type in a typedef so that we can use it in all our +- integration functions, and make it easy to change things. +-*/ +- +-struct gsl_monte_function_struct { +- double (*f)(double * x_array, size_t dim, void * params); +- size_t dim; +- void * params; +-}; +- +-typedef struct gsl_monte_function_struct gsl_monte_function; +- +-#define GSL_MONTE_FN_EVAL(F,x) (*((F)->f))(x,(F)->dim,(F)->params) +- +- +-__END_DECLS +- +-#endif /* __GSL_MONTE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_clausen.h (revision 14079) +@@ -1,52 +0,0 @@ +-/* specfunc/gsl_sf_clausen.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_CLAUSEN_H__ +-#define __GSL_SF_CLAUSEN_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Calculate the Clausen integral: +- * Cl_2(x) := Integrate[-Log[2 Sin[t/2]], {t,0,x}] +- * +- * Relation to dilogarithm: +- * Cl_2(theta) = Im[ Li_2(e^(i theta)) ] +- */ +-int gsl_sf_clausen_e(double x, gsl_sf_result * result); +-double gsl_sf_clausen(const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_CLAUSEN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long_double.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_LONG_DOUBLE_H__ +-#define __GSL_SORT_VECTOR_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_long_double (gsl_vector_long_double * v); +-int gsl_sort_vector_long_double_index (gsl_permutation * p, const gsl_vector_long_double * v); +- +-int gsl_sort_vector_long_double_smallest (long double * dest, const size_t k, const gsl_vector_long_double * v); +-int gsl_sort_vector_long_double_largest (long double * dest, const size_t k, const gsl_vector_long_double * v); +- +-int gsl_sort_vector_long_double_smallest_index (size_t * p, const size_t k, const gsl_vector_long_double * v); +-int gsl_sort_vector_long_double_largest_index (size_t * p, const size_t k, const gsl_vector_long_double * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dawson.h (revision 14079) +@@ -1,52 +0,0 @@ +-/* specfunc/gsl_sf_dawson.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_DAWSON_H__ +-#define __GSL_SF_DAWSON_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Dawson's integral: +- * +- * Exp[-x^2] Integral[ Exp[t^2], {t,0,x}] +- * +- * exceptions: GSL_EUNDRFLW; +- */ +-int gsl_sf_dawson_e(double x, gsl_sf_result * result); +-double gsl_sf_dawson(double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_DAWSON_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_psi.h (revision 14079) +@@ -1,113 +0,0 @@ +-/* specfunc/gsl_sf_psi.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_PSI_H__ +-#define __GSL_SF_PSI_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Poly-Gamma Functions +- * +- * psi(m,x) := (d/dx)^m psi(0,x) = (d/dx)^{m+1} log(gamma(x)) +- */ +- +- +-/* Di-Gamma Function psi(n) = psi(0,n) +- * +- * n > 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_psi_int_e(const int n, gsl_sf_result * result); +-double gsl_sf_psi_int(const int n); +- +- +-/* Di-Gamma Function psi(x) = psi(0, x) +- * +- * x != 0.0, -1.0, -2.0, ... +- * exceptions: GSL_EDOM, GSL_ELOSS +- */ +-int gsl_sf_psi_e(const double x, gsl_sf_result * result); +-double gsl_sf_psi(const double x); +- +- +-/* Di-Gamma Function Re[psi(1 + I y)] +- * +- * exceptions: none +- */ +-int gsl_sf_psi_1piy_e(const double y, gsl_sf_result * result); +-double gsl_sf_psi_1piy(const double y); +- +- +-/* Di-Gamma Function psi(z) for general complex argument z = x + iy +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_complex_psi_e( +- const double x, +- const double y, +- gsl_sf_result * result_re, +- gsl_sf_result * result_im +- ); +- +- +-/* Tri-Gamma Function psi^(1)(n) +- * +- * n > 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_psi_1_int_e(const int n, gsl_sf_result * result); +-double gsl_sf_psi_1_int(const int n); +- +- +-/* Tri-Gamma Function psi^(1)(x) +- * +- * x != 0.0, -1.0, -2.0, ... +- * exceptions: GSL_EDOM, GSL_ELOSS +- */ +-int gsl_sf_psi_1_e(const double x, gsl_sf_result * result); +-double gsl_sf_psi_1(const double x); +- +- +-/* Poly-Gamma Function psi^(n)(x) +- * +- * n >= 0, x > 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_psi_n_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_psi_n(const int n, const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_PSI_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_complex_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ +-#define __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_complex (const gsl_permutation * p, gsl_vector_complex * v); +-int gsl_permute_vector_complex_inverse (const gsl_permutation * p, gsl_vector_complex * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_transport.h (revision 14079) +@@ -1,78 +0,0 @@ +-/* specfunc/gsl_sf_transport.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_TRANSPORT_H__ +-#define __GSL_SF_TRANSPORT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Transport function: +- * J(n,x) := Integral[ t^n e^t /(e^t - 1)^2, {t,0,x}] +- */ +- +-/* J(2,x) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_transport_2_e(const double x, gsl_sf_result * result); +-double gsl_sf_transport_2(const double x); +- +- +-/* J(3,x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_transport_3_e(const double x, gsl_sf_result * result); +-double gsl_sf_transport_3(const double x); +- +- +-/* J(4,x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_transport_4_e(const double x, gsl_sf_result * result); +-double gsl_sf_transport_4(const double x); +- +- +-/* J(5,x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_transport_5_e(const double x, gsl_sf_result * result); +-double gsl_sf_transport_5(const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_TRANSPORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_message.h (revision 14079) +@@ -1,80 +0,0 @@ +-/* err/gsl_message.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MESSAGE_H__ +-#define __GSL_MESSAGE_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Provide a general messaging service for client use. Messages can +- * be selectively turned off at compile time by defining an +- * appropriate message mask. Client code which uses the GSL_MESSAGE() +- * macro must provide a mask which is or'ed with the GSL_MESSAGE_MASK. +- * +- * The messaging service can be completely turned off +- * by defining GSL_MESSAGING_OFF. */ +- +-void gsl_message(const char * message, const char * file, int line, +- unsigned int mask); +- +-#ifndef GSL_MESSAGE_MASK +-#define GSL_MESSAGE_MASK 0xffffffffu /* default all messages allowed */ +-#endif +- +-GSL_VAR unsigned int gsl_message_mask ; +- +-/* Provide some symolic masks for client ease of use. */ +- +-enum { +- GSL_MESSAGE_MASK_A = 1, +- GSL_MESSAGE_MASK_B = 2, +- GSL_MESSAGE_MASK_C = 4, +- GSL_MESSAGE_MASK_D = 8, +- GSL_MESSAGE_MASK_E = 16, +- GSL_MESSAGE_MASK_F = 32, +- GSL_MESSAGE_MASK_G = 64, +- GSL_MESSAGE_MASK_H = 128 +-} ; +- +-#ifdef GSL_MESSAGING_OFF /* throw away messages */ +-#define GSL_MESSAGE(message, mask) do { } while(0) +-#else /* output all messages */ +-#define GSL_MESSAGE(message, mask) \ +- do { \ +- if (mask & GSL_MESSAGE_MASK) \ +- gsl_message (message, __FILE__, __LINE__, mask) ; \ +- } while (0) +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MESSAGE_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_rng.h (revision 14079) +@@ -1,217 +0,0 @@ +-/* rng/gsl_rng.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 James Theiler, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_RNG_H__ +-#define __GSL_RNG_H__ +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +- { +- const char *name; +- unsigned long int max; +- unsigned long int min; +- size_t size; +- void (*set) (void *state, unsigned long int seed); +- unsigned long int (*get) (void *state); +- double (*get_double) (void *state); +- } +-gsl_rng_type; +- +-typedef struct +- { +- const gsl_rng_type * type; +- void *state; +- } +-gsl_rng; +- +- +-/* These structs also need to appear in default.c so you can select +- them via the environment variable GSL_RNG_TYPE */ +- +-GSL_VAR const gsl_rng_type *gsl_rng_borosh13; +-GSL_VAR const gsl_rng_type *gsl_rng_coveyou; +-GSL_VAR const gsl_rng_type *gsl_rng_cmrg; +-GSL_VAR const gsl_rng_type *gsl_rng_fishman18; +-GSL_VAR const gsl_rng_type *gsl_rng_fishman20; +-GSL_VAR const gsl_rng_type *gsl_rng_fishman2x; +-GSL_VAR const gsl_rng_type *gsl_rng_gfsr4; +-GSL_VAR const gsl_rng_type *gsl_rng_knuthran; +-GSL_VAR const gsl_rng_type *gsl_rng_knuthran2; +-GSL_VAR const gsl_rng_type *gsl_rng_knuthran2002; +-GSL_VAR const gsl_rng_type *gsl_rng_lecuyer21; +-GSL_VAR const gsl_rng_type *gsl_rng_minstd; +-GSL_VAR const gsl_rng_type *gsl_rng_mrg; +-GSL_VAR const gsl_rng_type *gsl_rng_mt19937; +-GSL_VAR const gsl_rng_type *gsl_rng_mt19937_1999; +-GSL_VAR const gsl_rng_type *gsl_rng_mt19937_1998; +-GSL_VAR const gsl_rng_type *gsl_rng_r250; +-GSL_VAR const gsl_rng_type *gsl_rng_ran0; +-GSL_VAR const gsl_rng_type *gsl_rng_ran1; +-GSL_VAR const gsl_rng_type *gsl_rng_ran2; +-GSL_VAR const gsl_rng_type *gsl_rng_ran3; +-GSL_VAR const gsl_rng_type *gsl_rng_rand; +-GSL_VAR const gsl_rng_type *gsl_rng_rand48; +-GSL_VAR const gsl_rng_type *gsl_rng_random128_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random128_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random128_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_random256_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random256_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random256_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_random32_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random32_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random32_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_random64_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random64_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random64_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_random8_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random8_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random8_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_random_bsd; +-GSL_VAR const gsl_rng_type *gsl_rng_random_glibc2; +-GSL_VAR const gsl_rng_type *gsl_rng_random_libc5; +-GSL_VAR const gsl_rng_type *gsl_rng_randu; +-GSL_VAR const gsl_rng_type *gsl_rng_ranf; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlux; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlux389; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlxd1; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlxd2; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlxs0; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlxs1; +-GSL_VAR const gsl_rng_type *gsl_rng_ranlxs2; +-GSL_VAR const gsl_rng_type *gsl_rng_ranmar; +-GSL_VAR const gsl_rng_type *gsl_rng_slatec; +-GSL_VAR const gsl_rng_type *gsl_rng_taus; +-GSL_VAR const gsl_rng_type *gsl_rng_taus2; +-GSL_VAR const gsl_rng_type *gsl_rng_taus113; +-GSL_VAR const gsl_rng_type *gsl_rng_transputer; +-GSL_VAR const gsl_rng_type *gsl_rng_tt800; +-GSL_VAR const gsl_rng_type *gsl_rng_uni; +-GSL_VAR const gsl_rng_type *gsl_rng_uni32; +-GSL_VAR const gsl_rng_type *gsl_rng_vax; +-GSL_VAR const gsl_rng_type *gsl_rng_waterman14; +-GSL_VAR const gsl_rng_type *gsl_rng_zuf; +- +-const gsl_rng_type ** gsl_rng_types_setup(void); +- +-GSL_VAR const gsl_rng_type *gsl_rng_default; +-GSL_VAR unsigned long int gsl_rng_default_seed; +- +-gsl_rng *gsl_rng_alloc (const gsl_rng_type * T); +-int gsl_rng_memcpy (gsl_rng * dest, const gsl_rng * src); +-gsl_rng *gsl_rng_clone (const gsl_rng * r); +- +-void gsl_rng_free (gsl_rng * r); +- +-void gsl_rng_set (const gsl_rng * r, unsigned long int seed); +-unsigned long int gsl_rng_max (const gsl_rng * r); +-unsigned long int gsl_rng_min (const gsl_rng * r); +-const char *gsl_rng_name (const gsl_rng * r); +- +-int gsl_rng_fread (FILE * stream, gsl_rng * r); +-int gsl_rng_fwrite (FILE * stream, const gsl_rng * r); +- +-size_t gsl_rng_size (const gsl_rng * r); +-void * gsl_rng_state (const gsl_rng * r); +- +-void gsl_rng_print_state (const gsl_rng * r); +- +-const gsl_rng_type * gsl_rng_env_setup (void); +- +-INLINE_DECL unsigned long int gsl_rng_get (const gsl_rng * r); +-INLINE_DECL double gsl_rng_uniform (const gsl_rng * r); +-INLINE_DECL double gsl_rng_uniform_pos (const gsl_rng * r); +-INLINE_DECL unsigned long int gsl_rng_uniform_int (const gsl_rng * r, unsigned long int n); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN unsigned long int +-gsl_rng_get (const gsl_rng * r) +-{ +- return (r->type->get) (r->state); +-} +- +-INLINE_FUN double +-gsl_rng_uniform (const gsl_rng * r) +-{ +- return (r->type->get_double) (r->state); +-} +- +-INLINE_FUN double +-gsl_rng_uniform_pos (const gsl_rng * r) +-{ +- double x ; +- do +- { +- x = (r->type->get_double) (r->state) ; +- } +- while (x == 0) ; +- +- return x ; +-} +- +-/* Note: to avoid integer overflow in (range+1) we work with scale = +- range/n = (max-min)/n rather than scale=(max-min+1)/n, this reduces +- efficiency slightly but avoids having to check for the out of range +- value. Note that range is typically O(2^32) so the addition of 1 +- is negligible in most usage. */ +- +-INLINE_FUN unsigned long int +-gsl_rng_uniform_int (const gsl_rng * r, unsigned long int n) +-{ +- unsigned long int offset = r->type->min; +- unsigned long int range = r->type->max - offset; +- unsigned long int scale; +- unsigned long int k; +- +- if (n > range || n == 0) +- { +- GSL_ERROR_VAL ("invalid n, either 0 or exceeds maximum value of generator", +- GSL_EINVAL, 0) ; +- } +- +- scale = range / n; +- +- do +- { +- k = (((r->type->get) (r->state)) - offset) / scale; +- } +- while (k >= n); +- +- return k; +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_RNG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_short.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_SHORT_H__ +-#define __GSL_SORT_VECTOR_SHORT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_short (gsl_vector_short * v); +-int gsl_sort_vector_short_index (gsl_permutation * p, const gsl_vector_short * v); +- +-int gsl_sort_vector_short_smallest (short * dest, const size_t k, const gsl_vector_short * v); +-int gsl_sort_vector_short_largest (short * dest, const size_t k, const gsl_vector_short * v); +- +-int gsl_sort_vector_short_smallest_index (size_t * p, const size_t k, const gsl_vector_short * v); +-int gsl_sort_vector_short_largest_index (size_t * p, const size_t k, const gsl_vector_short * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coulomb.h (revision 14079) +@@ -1,128 +0,0 @@ +-/* specfunc/gsl_sf_coulomb.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_COULOMB_H__ +-#define __GSL_SF_COULOMB_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Normalized hydrogenic bound states, radial dependence. */ +- +-/* R_1 := 2Z sqrt(Z) exp(-Z r) +- */ +-int gsl_sf_hydrogenicR_1_e(const double Z, const double r, gsl_sf_result * result); +-double gsl_sf_hydrogenicR_1(const double Z, const double r); +- +-/* R_n := norm exp(-Z r/n) (2Z/n)^l Laguerre[n-l-1, 2l+1, 2Z/n r] +- * +- * normalization such that psi(n,l,r) = R_n Y_{lm} +- */ +-int gsl_sf_hydrogenicR_e(const int n, const int l, const double Z, const double r, gsl_sf_result * result); +-double gsl_sf_hydrogenicR(const int n, const int l, const double Z, const double r); +- +- +-/* Coulomb wave functions F_{lam_F}(eta,x), G_{lam_G}(eta,x) +- * and their derivatives; lam_G := lam_F - k_lam_G +- * +- * lam_F, lam_G > -0.5 +- * x > 0.0 +- * +- * Conventions of Abramowitz+Stegun. +- * +- * Because there can be a large dynamic range of values, +- * overflows are handled gracefully. If an overflow occurs, +- * GSL_EOVRFLW is signalled and exponent(s) are returned +- * through exp_F, exp_G. These are such that +- * +- * F_L(eta,x) = fc[k_L] * exp(exp_F) +- * G_L(eta,x) = gc[k_L] * exp(exp_G) +- * F_L'(eta,x) = fcp[k_L] * exp(exp_F) +- * G_L'(eta,x) = gcp[k_L] * exp(exp_G) +- */ +-int +-gsl_sf_coulomb_wave_FG_e(const double eta, const double x, +- const double lam_F, +- const int k_lam_G, +- gsl_sf_result * F, gsl_sf_result * Fp, +- gsl_sf_result * G, gsl_sf_result * Gp, +- double * exp_F, double * exp_G); +- +- +-/* F_L(eta,x) as array */ +-int gsl_sf_coulomb_wave_F_array( +- double lam_min, int kmax, +- double eta, double x, +- double * fc_array, +- double * F_exponent +- ); +- +-/* F_L(eta,x), G_L(eta,x) as arrays */ +-int gsl_sf_coulomb_wave_FG_array(double lam_min, int kmax, +- double eta, double x, +- double * fc_array, double * gc_array, +- double * F_exponent, +- double * G_exponent +- ); +- +-/* F_L(eta,x), G_L(eta,x), F'_L(eta,x), G'_L(eta,x) as arrays */ +-int gsl_sf_coulomb_wave_FGp_array(double lam_min, int kmax, +- double eta, double x, +- double * fc_array, double * fcp_array, +- double * gc_array, double * gcp_array, +- double * F_exponent, +- double * G_exponent +- ); +- +-/* Coulomb wave function divided by the argument, +- * F(eta, x)/x. This is the function which reduces to +- * spherical Bessel functions in the limit eta->0. +- */ +-int gsl_sf_coulomb_wave_sphF_array(double lam_min, int kmax, +- double eta, double x, +- double * fc_array, +- double * F_exponent +- ); +- +- +-/* Coulomb wave function normalization constant. +- * [Abramowitz+Stegun 14.1.8, 14.1.9] +- */ +-int gsl_sf_coulomb_CL_e(double L, double eta, gsl_sf_result * result); +-int gsl_sf_coulomb_CL_array(double Lmin, int kmax, double eta, double * cl); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_COULOMB_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ulong.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_ULONG_H__ +-#define __GSL_STATISTICS_ULONG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_ulong_mean (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_variance (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_sd (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_variance_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ulong_sd_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ulong_tss (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_tss_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_ulong_absdev (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_skew (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_kurtosis (const unsigned long data[], const size_t stride, const size_t n); +-double gsl_stats_ulong_lag1_autocorrelation (const unsigned long data[], const size_t stride, const size_t n); +- +-double gsl_stats_ulong_covariance (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n); +-double gsl_stats_ulong_correlation (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_ulong_variance_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ulong_sd_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ulong_absdev_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ulong_skew_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_ulong_kurtosis_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_ulong_lag1_autocorrelation_m (const unsigned long data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_ulong_covariance_m (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_ulong_pvariance (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2); +-double gsl_stats_ulong_ttest (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2); +- +-unsigned long gsl_stats_ulong_max (const unsigned long data[], const size_t stride, const size_t n); +-unsigned long gsl_stats_ulong_min (const unsigned long data[], const size_t stride, const size_t n); +-void gsl_stats_ulong_minmax (unsigned long * min, unsigned long * max, const unsigned long data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_ulong_max_index (const unsigned long data[], const size_t stride, const size_t n); +-size_t gsl_stats_ulong_min_index (const unsigned long data[], const size_t stride, const size_t n); +-void gsl_stats_ulong_minmax_index (size_t * min_index, size_t * max_index, const unsigned long data[], const size_t stride, const size_t n); +- +-double gsl_stats_ulong_median_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_ulong_quantile_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_combination.h (revision 14079) +@@ -1,92 +0,0 @@ +-/* combination/gsl_combination.h +- * based on permutation/gsl_permutation.h by Brian Gough +- * +- * Copyright (C) 2001 Szymon Jaroszewicz +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_COMBINATION_H__ +-#define __GSL_COMBINATION_H__ +- +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_combination_struct +-{ +- size_t n; +- size_t k; +- size_t *data; +-}; +- +-typedef struct gsl_combination_struct gsl_combination; +- +-gsl_combination *gsl_combination_alloc (const size_t n, const size_t k); +-gsl_combination *gsl_combination_calloc (const size_t n, const size_t k); +-void gsl_combination_init_first (gsl_combination * c); +-void gsl_combination_init_last (gsl_combination * c); +-void gsl_combination_free (gsl_combination * c); +-int gsl_combination_memcpy (gsl_combination * dest, const gsl_combination * src); +- +-int gsl_combination_fread (FILE * stream, gsl_combination * c); +-int gsl_combination_fwrite (FILE * stream, const gsl_combination * c); +-int gsl_combination_fscanf (FILE * stream, gsl_combination * c); +-int gsl_combination_fprintf (FILE * stream, const gsl_combination * c, const char *format); +- +-size_t gsl_combination_n (const gsl_combination * c); +-size_t gsl_combination_k (const gsl_combination * c); +-size_t * gsl_combination_data (const gsl_combination * c); +- +-int gsl_combination_valid (gsl_combination * c); +-int gsl_combination_next (gsl_combination * c); +-int gsl_combination_prev (gsl_combination * c); +- +-INLINE_DECL size_t gsl_combination_get (const gsl_combination * c, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-size_t +-gsl_combination_get (const gsl_combination * c, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= c->k)) /* size_t is unsigned, can't be negative */ +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return c->data[i]; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_COMBINATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_num.h (revision 14079) +@@ -1,43 +0,0 @@ +-/* const/gsl_const_num.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- * 2006, 2007, 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST_NUM__ +-#define __GSL_CONST_NUM__ +- +-#define GSL_CONST_NUM_FINE_STRUCTURE (7.297352533e-3) /* 1 */ +-#define GSL_CONST_NUM_AVOGADRO (6.02214199e23) /* 1 / mol */ +-#define GSL_CONST_NUM_YOTTA (1e24) /* 1 */ +-#define GSL_CONST_NUM_ZETTA (1e21) /* 1 */ +-#define GSL_CONST_NUM_EXA (1e18) /* 1 */ +-#define GSL_CONST_NUM_PETA (1e15) /* 1 */ +-#define GSL_CONST_NUM_TERA (1e12) /* 1 */ +-#define GSL_CONST_NUM_GIGA (1e9) /* 1 */ +-#define GSL_CONST_NUM_MEGA (1e6) /* 1 */ +-#define GSL_CONST_NUM_KILO (1e3) /* 1 */ +-#define GSL_CONST_NUM_MILLI (1e-3) /* 1 */ +-#define GSL_CONST_NUM_MICRO (1e-6) /* 1 */ +-#define GSL_CONST_NUM_NANO (1e-9) /* 1 */ +-#define GSL_CONST_NUM_PICO (1e-12) /* 1 */ +-#define GSL_CONST_NUM_FEMTO (1e-15) /* 1 */ +-#define GSL_CONST_NUM_ATTO (1e-18) /* 1 */ +-#define GSL_CONST_NUM_ZEPTO (1e-21) /* 1 */ +-#define GSL_CONST_NUM_YOCTO (1e-24) /* 1 */ +- +-#endif /* __GSL_CONST_NUM__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ushort.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_USHORT_H__ +-#define __GSL_VECTOR_USHORT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- unsigned short *data; +- gsl_block_ushort *block; +- int owner; +-} +-gsl_vector_ushort; +- +-typedef struct +-{ +- gsl_vector_ushort vector; +-} _gsl_vector_ushort_view; +- +-typedef _gsl_vector_ushort_view gsl_vector_ushort_view; +- +-typedef struct +-{ +- gsl_vector_ushort vector; +-} _gsl_vector_ushort_const_view; +- +-typedef const _gsl_vector_ushort_const_view gsl_vector_ushort_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_ushort *gsl_vector_ushort_alloc (const size_t n); +-gsl_vector_ushort *gsl_vector_ushort_calloc (const size_t n); +- +-gsl_vector_ushort *gsl_vector_ushort_alloc_from_block (gsl_block_ushort * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_ushort *gsl_vector_ushort_alloc_from_vector (gsl_vector_ushort * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_ushort_free (gsl_vector_ushort * v); +- +-/* Views */ +- +-_gsl_vector_ushort_view +-gsl_vector_ushort_view_array (unsigned short *v, size_t n); +- +-_gsl_vector_ushort_view +-gsl_vector_ushort_view_array_with_stride (unsigned short *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_ushort_const_view +-gsl_vector_ushort_const_view_array (const unsigned short *v, size_t n); +- +-_gsl_vector_ushort_const_view +-gsl_vector_ushort_const_view_array_with_stride (const unsigned short *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_ushort_view +-gsl_vector_ushort_subvector (gsl_vector_ushort *v, +- size_t i, +- size_t n); +- +-_gsl_vector_ushort_view +-gsl_vector_ushort_subvector_with_stride (gsl_vector_ushort *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_ushort_const_view +-gsl_vector_ushort_const_subvector (const gsl_vector_ushort *v, +- size_t i, +- size_t n); +- +-_gsl_vector_ushort_const_view +-gsl_vector_ushort_const_subvector_with_stride (const gsl_vector_ushort *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_ushort_set_zero (gsl_vector_ushort * v); +-void gsl_vector_ushort_set_all (gsl_vector_ushort * v, unsigned short x); +-int gsl_vector_ushort_set_basis (gsl_vector_ushort * v, size_t i); +- +-int gsl_vector_ushort_fread (FILE * stream, gsl_vector_ushort * v); +-int gsl_vector_ushort_fwrite (FILE * stream, const gsl_vector_ushort * v); +-int gsl_vector_ushort_fscanf (FILE * stream, gsl_vector_ushort * v); +-int gsl_vector_ushort_fprintf (FILE * stream, const gsl_vector_ushort * v, +- const char *format); +- +-int gsl_vector_ushort_memcpy (gsl_vector_ushort * dest, const gsl_vector_ushort * src); +- +-int gsl_vector_ushort_reverse (gsl_vector_ushort * v); +- +-int gsl_vector_ushort_swap (gsl_vector_ushort * v, gsl_vector_ushort * w); +-int gsl_vector_ushort_swap_elements (gsl_vector_ushort * v, const size_t i, const size_t j); +- +-unsigned short gsl_vector_ushort_max (const gsl_vector_ushort * v); +-unsigned short gsl_vector_ushort_min (const gsl_vector_ushort * v); +-void gsl_vector_ushort_minmax (const gsl_vector_ushort * v, unsigned short * min_out, unsigned short * max_out); +- +-size_t gsl_vector_ushort_max_index (const gsl_vector_ushort * v); +-size_t gsl_vector_ushort_min_index (const gsl_vector_ushort * v); +-void gsl_vector_ushort_minmax_index (const gsl_vector_ushort * v, size_t * imin, size_t * imax); +- +-int gsl_vector_ushort_add (gsl_vector_ushort * a, const gsl_vector_ushort * b); +-int gsl_vector_ushort_sub (gsl_vector_ushort * a, const gsl_vector_ushort * b); +-int gsl_vector_ushort_mul (gsl_vector_ushort * a, const gsl_vector_ushort * b); +-int gsl_vector_ushort_div (gsl_vector_ushort * a, const gsl_vector_ushort * b); +-int gsl_vector_ushort_scale (gsl_vector_ushort * a, const double x); +-int gsl_vector_ushort_add_constant (gsl_vector_ushort * a, const double x); +- +-int gsl_vector_ushort_equal (const gsl_vector_ushort * u, +- const gsl_vector_ushort * v); +- +-int gsl_vector_ushort_isnull (const gsl_vector_ushort * v); +-int gsl_vector_ushort_ispos (const gsl_vector_ushort * v); +-int gsl_vector_ushort_isneg (const gsl_vector_ushort * v); +-int gsl_vector_ushort_isnonneg (const gsl_vector_ushort * v); +- +-INLINE_DECL unsigned short gsl_vector_ushort_get (const gsl_vector_ushort * v, const size_t i); +-INLINE_DECL void gsl_vector_ushort_set (gsl_vector_ushort * v, const size_t i, unsigned short x); +-INLINE_DECL unsigned short * gsl_vector_ushort_ptr (gsl_vector_ushort * v, const size_t i); +-INLINE_DECL const unsigned short * gsl_vector_ushort_const_ptr (const gsl_vector_ushort * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-unsigned short +-gsl_vector_ushort_get (const gsl_vector_ushort * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_ushort_set (gsl_vector_ushort * v, const size_t i, unsigned short x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-unsigned short * +-gsl_vector_ushort_ptr (gsl_vector_ushort * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (unsigned short *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const unsigned short * +-gsl_vector_ushort_const_ptr (const gsl_vector_ushort * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const unsigned short *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_USHORT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_complex_float.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_COMPLEX_FLOAT_H__ +-#define __GSL_BLOCK_COMPLEX_FLOAT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_complex_float_struct +-{ +- size_t size; +- float *data; +-}; +- +-typedef struct gsl_block_complex_float_struct gsl_block_complex_float; +- +-gsl_block_complex_float *gsl_block_complex_float_alloc (const size_t n); +-gsl_block_complex_float *gsl_block_complex_float_calloc (const size_t n); +-void gsl_block_complex_float_free (gsl_block_complex_float * b); +- +-int gsl_block_complex_float_fread (FILE * stream, gsl_block_complex_float * b); +-int gsl_block_complex_float_fwrite (FILE * stream, const gsl_block_complex_float * b); +-int gsl_block_complex_float_fscanf (FILE * stream, gsl_block_complex_float * b); +-int gsl_block_complex_float_fprintf (FILE * stream, const gsl_block_complex_float * b, const char *format); +- +-int gsl_block_complex_float_raw_fread (FILE * stream, float * b, const size_t n, const size_t stride); +-int gsl_block_complex_float_raw_fwrite (FILE * stream, const float * b, const size_t n, const size_t stride); +-int gsl_block_complex_float_raw_fscanf (FILE * stream, float * b, const size_t n, const size_t stride); +-int gsl_block_complex_float_raw_fprintf (FILE * stream, const float * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_complex_float_size (const gsl_block_complex_float * b); +-float * gsl_block_complex_float_data (const gsl_block_complex_float * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_ulong.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_ULONG_H__ +-#define __GSL_MATRIX_ULONG_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- unsigned long * data; +- gsl_block_ulong * block; +- int owner; +-} gsl_matrix_ulong; +- +-typedef struct +-{ +- gsl_matrix_ulong matrix; +-} _gsl_matrix_ulong_view; +- +-typedef _gsl_matrix_ulong_view gsl_matrix_ulong_view; +- +-typedef struct +-{ +- gsl_matrix_ulong matrix; +-} _gsl_matrix_ulong_const_view; +- +-typedef const _gsl_matrix_ulong_const_view gsl_matrix_ulong_const_view; +- +-/* Allocation */ +- +-gsl_matrix_ulong * +-gsl_matrix_ulong_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_ulong * +-gsl_matrix_ulong_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_ulong * +-gsl_matrix_ulong_alloc_from_block (gsl_block_ulong * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_ulong * +-gsl_matrix_ulong_alloc_from_matrix (gsl_matrix_ulong * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_ulong * +-gsl_vector_ulong_alloc_row_from_matrix (gsl_matrix_ulong * m, +- const size_t i); +- +-gsl_vector_ulong * +-gsl_vector_ulong_alloc_col_from_matrix (gsl_matrix_ulong * m, +- const size_t j); +- +-void gsl_matrix_ulong_free (gsl_matrix_ulong * m); +- +-/* Views */ +- +-_gsl_matrix_ulong_view +-gsl_matrix_ulong_submatrix (gsl_matrix_ulong * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_row (gsl_matrix_ulong * m, const size_t i); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_column (gsl_matrix_ulong * m, const size_t j); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_diagonal (gsl_matrix_ulong * m); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_subdiagonal (gsl_matrix_ulong * m, const size_t k); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_superdiagonal (gsl_matrix_ulong * m, const size_t k); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_subrow (gsl_matrix_ulong * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_ulong_view +-gsl_matrix_ulong_subcolumn (gsl_matrix_ulong * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_ulong_view +-gsl_matrix_ulong_view_array (unsigned long * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ulong_view +-gsl_matrix_ulong_view_array_with_tda (unsigned long * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_ulong_view +-gsl_matrix_ulong_view_vector (gsl_vector_ulong * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ulong_view +-gsl_matrix_ulong_view_vector_with_tda (gsl_vector_ulong * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_ulong_const_view +-gsl_matrix_ulong_const_submatrix (const gsl_matrix_ulong * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_row (const gsl_matrix_ulong * m, +- const size_t i); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_column (const gsl_matrix_ulong * m, +- const size_t j); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_diagonal (const gsl_matrix_ulong * m); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_subdiagonal (const gsl_matrix_ulong * m, +- const size_t k); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_superdiagonal (const gsl_matrix_ulong * m, +- const size_t k); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_subrow (const gsl_matrix_ulong * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_ulong_const_view +-gsl_matrix_ulong_const_subcolumn (const gsl_matrix_ulong * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_ulong_const_view +-gsl_matrix_ulong_const_view_array (const unsigned long * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ulong_const_view +-gsl_matrix_ulong_const_view_array_with_tda (const unsigned long * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_ulong_const_view +-gsl_matrix_ulong_const_view_vector (const gsl_vector_ulong * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_ulong_const_view +-gsl_matrix_ulong_const_view_vector_with_tda (const gsl_vector_ulong * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_ulong_set_zero (gsl_matrix_ulong * m); +-void gsl_matrix_ulong_set_identity (gsl_matrix_ulong * m); +-void gsl_matrix_ulong_set_all (gsl_matrix_ulong * m, unsigned long x); +- +-int gsl_matrix_ulong_fread (FILE * stream, gsl_matrix_ulong * m) ; +-int gsl_matrix_ulong_fwrite (FILE * stream, const gsl_matrix_ulong * m) ; +-int gsl_matrix_ulong_fscanf (FILE * stream, gsl_matrix_ulong * m); +-int gsl_matrix_ulong_fprintf (FILE * stream, const gsl_matrix_ulong * m, const char * format); +- +-int gsl_matrix_ulong_memcpy(gsl_matrix_ulong * dest, const gsl_matrix_ulong * src); +-int gsl_matrix_ulong_swap(gsl_matrix_ulong * m1, gsl_matrix_ulong * m2); +- +-int gsl_matrix_ulong_swap_rows(gsl_matrix_ulong * m, const size_t i, const size_t j); +-int gsl_matrix_ulong_swap_columns(gsl_matrix_ulong * m, const size_t i, const size_t j); +-int gsl_matrix_ulong_swap_rowcol(gsl_matrix_ulong * m, const size_t i, const size_t j); +-int gsl_matrix_ulong_transpose (gsl_matrix_ulong * m); +-int gsl_matrix_ulong_transpose_memcpy (gsl_matrix_ulong * dest, const gsl_matrix_ulong * src); +- +-unsigned long gsl_matrix_ulong_max (const gsl_matrix_ulong * m); +-unsigned long gsl_matrix_ulong_min (const gsl_matrix_ulong * m); +-void gsl_matrix_ulong_minmax (const gsl_matrix_ulong * m, unsigned long * min_out, unsigned long * max_out); +- +-void gsl_matrix_ulong_max_index (const gsl_matrix_ulong * m, size_t * imax, size_t *jmax); +-void gsl_matrix_ulong_min_index (const gsl_matrix_ulong * m, size_t * imin, size_t *jmin); +-void gsl_matrix_ulong_minmax_index (const gsl_matrix_ulong * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_ulong_equal (const gsl_matrix_ulong * a, const gsl_matrix_ulong * b); +- +-int gsl_matrix_ulong_isnull (const gsl_matrix_ulong * m); +-int gsl_matrix_ulong_ispos (const gsl_matrix_ulong * m); +-int gsl_matrix_ulong_isneg (const gsl_matrix_ulong * m); +-int gsl_matrix_ulong_isnonneg (const gsl_matrix_ulong * m); +- +-int gsl_matrix_ulong_add (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); +-int gsl_matrix_ulong_sub (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); +-int gsl_matrix_ulong_mul_elements (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); +-int gsl_matrix_ulong_div_elements (gsl_matrix_ulong * a, const gsl_matrix_ulong * b); +-int gsl_matrix_ulong_scale (gsl_matrix_ulong * a, const double x); +-int gsl_matrix_ulong_add_constant (gsl_matrix_ulong * a, const double x); +-int gsl_matrix_ulong_add_diagonal (gsl_matrix_ulong * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_ulong_get_row(gsl_vector_ulong * v, const gsl_matrix_ulong * m, const size_t i); +-int gsl_matrix_ulong_get_col(gsl_vector_ulong * v, const gsl_matrix_ulong * m, const size_t j); +-int gsl_matrix_ulong_set_row(gsl_matrix_ulong * m, const size_t i, const gsl_vector_ulong * v); +-int gsl_matrix_ulong_set_col(gsl_matrix_ulong * m, const size_t j, const gsl_vector_ulong * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL unsigned long gsl_matrix_ulong_get(const gsl_matrix_ulong * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_ulong_set(gsl_matrix_ulong * m, const size_t i, const size_t j, const unsigned long x); +-INLINE_DECL unsigned long * gsl_matrix_ulong_ptr(gsl_matrix_ulong * m, const size_t i, const size_t j); +-INLINE_DECL const unsigned long * gsl_matrix_ulong_const_ptr(const gsl_matrix_ulong * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-unsigned long +-gsl_matrix_ulong_get(const gsl_matrix_ulong * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_ulong_set(gsl_matrix_ulong * m, const size_t i, const size_t j, const unsigned long x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-unsigned long * +-gsl_matrix_ulong_ptr(gsl_matrix_ulong * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (unsigned long *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const unsigned long * +-gsl_matrix_ulong_const_ptr(const gsl_matrix_ulong * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const unsigned long *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_deriv.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* deriv/gsl_deriv.h +- * +- * Copyright (C) 2000 David Morrison +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_DERIV_H__ +-#define __GSL_DERIV_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_deriv_central (const gsl_function *f, +- double x, double h, +- double *result, double *abserr); +- +-int gsl_deriv_backward (const gsl_function *f, +- double x, double h, +- double *result, double *abserr); +- +-int gsl_deriv_forward (const gsl_function *f, +- double x, double h, +- double *result, double *abserr); +- +-__END_DECLS +- +-#endif /* __GSL_DERIV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uchar.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_UCHAR_H__ +-#define __GSL_SORT_UCHAR_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_uchar (unsigned char * data, const size_t stride, const size_t n); +-void gsl_sort_uchar_index (size_t * p, const unsigned char * data, const size_t stride, const size_t n); +- +-int gsl_sort_uchar_smallest (unsigned char * dest, const size_t k, const unsigned char * src, const size_t stride, const size_t n); +-int gsl_sort_uchar_smallest_index (size_t * p, const size_t k, const unsigned char * src, const size_t stride, const size_t n); +- +-int gsl_sort_uchar_largest (unsigned char * dest, const size_t k, const unsigned char * src, const size_t stride, const size_t n); +-int gsl_sort_uchar_largest_index (size_t * p, const size_t k, const unsigned char * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_gamma.h (revision 14079) +@@ -1,293 +0,0 @@ +-/* specfunc/gsl_sf_gamma.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_GAMMA_H__ +-#define __GSL_SF_GAMMA_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Log[Gamma(x)], x not a negative integer +- * Uses real Lanczos method. +- * Returns the real part of Log[Gamma[x]] when x < 0, +- * i.e. Log[|Gamma[x]|]. +- * +- * exceptions: GSL_EDOM, GSL_EROUND +- */ +-int gsl_sf_lngamma_e(double x, gsl_sf_result * result); +-double gsl_sf_lngamma(const double x); +- +- +-/* Log[Gamma(x)], x not a negative integer +- * Uses real Lanczos method. Determines +- * the sign of Gamma[x] as well as Log[|Gamma[x]|] for x < 0. +- * So Gamma[x] = sgn * Exp[result_lg]. +- * +- * exceptions: GSL_EDOM, GSL_EROUND +- */ +-int gsl_sf_lngamma_sgn_e(double x, gsl_sf_result * result_lg, double *sgn); +- +- +-/* Gamma(x), x not a negative integer +- * Uses real Lanczos method. +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EROUND +- */ +-int gsl_sf_gamma_e(const double x, gsl_sf_result * result); +-double gsl_sf_gamma(const double x); +- +- +-/* Regulated Gamma Function, x > 0 +- * Gamma^*(x) = Gamma(x)/(Sqrt[2Pi] x^(x-1/2) exp(-x)) +- * = (1 + 1/(12x) + ...), x->Inf +- * A useful suggestion of Temme. +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gammastar_e(const double x, gsl_sf_result * result); +-double gsl_sf_gammastar(const double x); +- +- +-/* 1/Gamma(x) +- * Uses real Lanczos method. +- * +- * exceptions: GSL_EUNDRFLW, GSL_EROUND +- */ +-int gsl_sf_gammainv_e(const double x, gsl_sf_result * result); +-double gsl_sf_gammainv(const double x); +- +- +-/* Log[Gamma(z)] for z complex, z not a negative integer +- * Uses complex Lanczos method. Note that the phase part (arg) +- * is not well-determined when |z| is very large, due +- * to inevitable roundoff in restricting to (-Pi,Pi]. +- * This will raise the GSL_ELOSS exception when it occurs. +- * The absolute value part (lnr), however, never suffers. +- * +- * Calculates: +- * lnr = log|Gamma(z)| +- * arg = arg(Gamma(z)) in (-Pi, Pi] +- * +- * exceptions: GSL_EDOM, GSL_ELOSS +- */ +-int gsl_sf_lngamma_complex_e(double zr, double zi, gsl_sf_result * lnr, gsl_sf_result * arg); +- +- +-/* x^n / n! +- * +- * x >= 0.0, n >= 0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_taylorcoeff_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_taylorcoeff(const int n, const double x); +- +- +-/* n! +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_fact_e(const unsigned int n, gsl_sf_result * result); +-double gsl_sf_fact(const unsigned int n); +- +- +-/* n!! = n(n-2)(n-4) ... +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_doublefact_e(const unsigned int n, gsl_sf_result * result); +-double gsl_sf_doublefact(const unsigned int n); +- +- +-/* log(n!) +- * Faster than ln(Gamma(n+1)) for n < 170; defers for larger n. +- * +- * exceptions: none +- */ +-int gsl_sf_lnfact_e(const unsigned int n, gsl_sf_result * result); +-double gsl_sf_lnfact(const unsigned int n); +- +- +-/* log(n!!) +- * +- * exceptions: none +- */ +-int gsl_sf_lndoublefact_e(const unsigned int n, gsl_sf_result * result); +-double gsl_sf_lndoublefact(const unsigned int n); +- +- +-/* log(n choose m) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_lnchoose_e(unsigned int n, unsigned int m, gsl_sf_result * result); +-double gsl_sf_lnchoose(unsigned int n, unsigned int m); +- +- +-/* n choose m +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_choose_e(unsigned int n, unsigned int m, gsl_sf_result * result); +-double gsl_sf_choose(unsigned int n, unsigned int m); +- +- +-/* Logarithm of Pochhammer (Apell) symbol +- * log( (a)_x ) +- * where (a)_x := Gamma[a + x]/Gamma[a] +- * +- * a > 0, a+x > 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_lnpoch_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_lnpoch(const double a, const double x); +- +- +-/* Logarithm of Pochhammer (Apell) symbol, with sign information. +- * result = log( |(a)_x| ) +- * sgn = sgn( (a)_x ) +- * where (a)_x := Gamma[a + x]/Gamma[a] +- * +- * a != neg integer, a+x != neg integer +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_lnpoch_sgn_e(const double a, const double x, gsl_sf_result * result, double * sgn); +- +- +-/* Pochhammer (Apell) symbol +- * (a)_x := Gamma[a + x]/Gamma[x] +- * +- * a != neg integer, a+x != neg integer +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_poch_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_poch(const double a, const double x); +- +- +-/* Relative Pochhammer (Apell) symbol +- * ((a,x) - 1)/x +- * where (a,x) = (a)_x := Gamma[a + x]/Gamma[a] +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_pochrel_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_pochrel(const double a, const double x); +- +- +-/* Normalized Incomplete Gamma Function +- * +- * Q(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,x,Infinity} ] +- * +- * a >= 0, x >= 0 +- * Q(a,0) := 1 +- * Q(0,x) := 0, x != 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gamma_inc_Q_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_gamma_inc_Q(const double a, const double x); +- +- +-/* Complementary Normalized Incomplete Gamma Function +- * +- * P(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,0,x} ] +- * +- * a > 0, x >= 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gamma_inc_P_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_gamma_inc_P(const double a, const double x); +- +- +-/* Non-normalized Incomplete Gamma Function +- * +- * Gamma(a,x) := Integral[ t^(a-1) e^(-t), {t,x,Infinity} ] +- * +- * x >= 0.0 +- * Gamma(a, 0) := Gamma(a) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_gamma_inc_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_gamma_inc(const double a, const double x); +- +- +-/* Logarithm of Beta Function +- * Log[B(a,b)] +- * +- * a > 0, b > 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_lnbeta_e(const double a, const double b, gsl_sf_result * result); +-double gsl_sf_lnbeta(const double a, const double b); +- +-int gsl_sf_lnbeta_sgn_e(const double x, const double y, gsl_sf_result * result, double * sgn); +- +- +-/* Beta Function +- * B(a,b) +- * +- * a > 0, b > 0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_beta_e(const double a, const double b, gsl_sf_result * result); +-double gsl_sf_beta(const double a, const double b); +- +- +-/* Normalized Incomplete Beta Function +- * B_x(a,b)/B(a,b) +- * +- * a > 0, b > 0, 0 <= x <= 1 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_beta_inc_e(const double a, const double b, const double x, gsl_sf_result * result); +-double gsl_sf_beta_inc(const double a, const double b, const double x); +- +- +-/* The maximum x such that gamma(x) is not +- * considered an overflow. +- */ +-#define GSL_SF_GAMMA_XMAX 171.0 +- +-/* The maximum n such that gsl_sf_fact(n) does not give an overflow. */ +-#define GSL_SF_FACT_NMAX 170 +- +-/* The maximum n such that gsl_sf_doublefact(n) does not give an overflow. */ +-#define GSL_SF_DOUBLEFACT_NMAX 297 +- +-__END_DECLS +- +-#endif /* __GSL_SF_GAMMA_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_double.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_DOUBLE_H__ +-#define __GSL_PERMUTE_DOUBLE_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute (const size_t * p, double * data, const size_t stride, const size_t n); +-int gsl_permute_inverse (const size_t * p, double * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long_double.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_LONG_DOUBLE_H__ +-#define __GSL_VECTOR_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- long double *data; +- gsl_block_long_double *block; +- int owner; +-} +-gsl_vector_long_double; +- +-typedef struct +-{ +- gsl_vector_long_double vector; +-} _gsl_vector_long_double_view; +- +-typedef _gsl_vector_long_double_view gsl_vector_long_double_view; +- +-typedef struct +-{ +- gsl_vector_long_double vector; +-} _gsl_vector_long_double_const_view; +- +-typedef const _gsl_vector_long_double_const_view gsl_vector_long_double_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_long_double *gsl_vector_long_double_alloc (const size_t n); +-gsl_vector_long_double *gsl_vector_long_double_calloc (const size_t n); +- +-gsl_vector_long_double *gsl_vector_long_double_alloc_from_block (gsl_block_long_double * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_long_double *gsl_vector_long_double_alloc_from_vector (gsl_vector_long_double * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_long_double_free (gsl_vector_long_double * v); +- +-/* Views */ +- +-_gsl_vector_long_double_view +-gsl_vector_long_double_view_array (long double *v, size_t n); +- +-_gsl_vector_long_double_view +-gsl_vector_long_double_view_array_with_stride (long double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_double_const_view +-gsl_vector_long_double_const_view_array (const long double *v, size_t n); +- +-_gsl_vector_long_double_const_view +-gsl_vector_long_double_const_view_array_with_stride (const long double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_double_view +-gsl_vector_long_double_subvector (gsl_vector_long_double *v, +- size_t i, +- size_t n); +- +-_gsl_vector_long_double_view +-gsl_vector_long_double_subvector_with_stride (gsl_vector_long_double *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_double_const_view +-gsl_vector_long_double_const_subvector (const gsl_vector_long_double *v, +- size_t i, +- size_t n); +- +-_gsl_vector_long_double_const_view +-gsl_vector_long_double_const_subvector_with_stride (const gsl_vector_long_double *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_long_double_set_zero (gsl_vector_long_double * v); +-void gsl_vector_long_double_set_all (gsl_vector_long_double * v, long double x); +-int gsl_vector_long_double_set_basis (gsl_vector_long_double * v, size_t i); +- +-int gsl_vector_long_double_fread (FILE * stream, gsl_vector_long_double * v); +-int gsl_vector_long_double_fwrite (FILE * stream, const gsl_vector_long_double * v); +-int gsl_vector_long_double_fscanf (FILE * stream, gsl_vector_long_double * v); +-int gsl_vector_long_double_fprintf (FILE * stream, const gsl_vector_long_double * v, +- const char *format); +- +-int gsl_vector_long_double_memcpy (gsl_vector_long_double * dest, const gsl_vector_long_double * src); +- +-int gsl_vector_long_double_reverse (gsl_vector_long_double * v); +- +-int gsl_vector_long_double_swap (gsl_vector_long_double * v, gsl_vector_long_double * w); +-int gsl_vector_long_double_swap_elements (gsl_vector_long_double * v, const size_t i, const size_t j); +- +-long double gsl_vector_long_double_max (const gsl_vector_long_double * v); +-long double gsl_vector_long_double_min (const gsl_vector_long_double * v); +-void gsl_vector_long_double_minmax (const gsl_vector_long_double * v, long double * min_out, long double * max_out); +- +-size_t gsl_vector_long_double_max_index (const gsl_vector_long_double * v); +-size_t gsl_vector_long_double_min_index (const gsl_vector_long_double * v); +-void gsl_vector_long_double_minmax_index (const gsl_vector_long_double * v, size_t * imin, size_t * imax); +- +-int gsl_vector_long_double_add (gsl_vector_long_double * a, const gsl_vector_long_double * b); +-int gsl_vector_long_double_sub (gsl_vector_long_double * a, const gsl_vector_long_double * b); +-int gsl_vector_long_double_mul (gsl_vector_long_double * a, const gsl_vector_long_double * b); +-int gsl_vector_long_double_div (gsl_vector_long_double * a, const gsl_vector_long_double * b); +-int gsl_vector_long_double_scale (gsl_vector_long_double * a, const double x); +-int gsl_vector_long_double_add_constant (gsl_vector_long_double * a, const double x); +- +-int gsl_vector_long_double_equal (const gsl_vector_long_double * u, +- const gsl_vector_long_double * v); +- +-int gsl_vector_long_double_isnull (const gsl_vector_long_double * v); +-int gsl_vector_long_double_ispos (const gsl_vector_long_double * v); +-int gsl_vector_long_double_isneg (const gsl_vector_long_double * v); +-int gsl_vector_long_double_isnonneg (const gsl_vector_long_double * v); +- +-INLINE_DECL long double gsl_vector_long_double_get (const gsl_vector_long_double * v, const size_t i); +-INLINE_DECL void gsl_vector_long_double_set (gsl_vector_long_double * v, const size_t i, long double x); +-INLINE_DECL long double * gsl_vector_long_double_ptr (gsl_vector_long_double * v, const size_t i); +-INLINE_DECL const long double * gsl_vector_long_double_const_ptr (const gsl_vector_long_double * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-long double +-gsl_vector_long_double_get (const gsl_vector_long_double * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_long_double_set (gsl_vector_long_double * v, const size_t i, long double x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-long double * +-gsl_vector_long_double_ptr (gsl_vector_long_double * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (long double *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const long double * +-gsl_vector_long_double_const_ptr (const gsl_vector_long_double * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const long double *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_LONG_DOUBLE_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long_double.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_LONG_DOUBLE_H__ +-#define __GSL_MATRIX_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- long double * data; +- gsl_block_long_double * block; +- int owner; +-} gsl_matrix_long_double; +- +-typedef struct +-{ +- gsl_matrix_long_double matrix; +-} _gsl_matrix_long_double_view; +- +-typedef _gsl_matrix_long_double_view gsl_matrix_long_double_view; +- +-typedef struct +-{ +- gsl_matrix_long_double matrix; +-} _gsl_matrix_long_double_const_view; +- +-typedef const _gsl_matrix_long_double_const_view gsl_matrix_long_double_const_view; +- +-/* Allocation */ +- +-gsl_matrix_long_double * +-gsl_matrix_long_double_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_long_double * +-gsl_matrix_long_double_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_long_double * +-gsl_matrix_long_double_alloc_from_block (gsl_block_long_double * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_long_double * +-gsl_matrix_long_double_alloc_from_matrix (gsl_matrix_long_double * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_long_double * +-gsl_vector_long_double_alloc_row_from_matrix (gsl_matrix_long_double * m, +- const size_t i); +- +-gsl_vector_long_double * +-gsl_vector_long_double_alloc_col_from_matrix (gsl_matrix_long_double * m, +- const size_t j); +- +-void gsl_matrix_long_double_free (gsl_matrix_long_double * m); +- +-/* Views */ +- +-_gsl_matrix_long_double_view +-gsl_matrix_long_double_submatrix (gsl_matrix_long_double * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_row (gsl_matrix_long_double * m, const size_t i); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_column (gsl_matrix_long_double * m, const size_t j); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_diagonal (gsl_matrix_long_double * m); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_subdiagonal (gsl_matrix_long_double * m, const size_t k); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_superdiagonal (gsl_matrix_long_double * m, const size_t k); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_subrow (gsl_matrix_long_double * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_long_double_view +-gsl_matrix_long_double_subcolumn (gsl_matrix_long_double * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_long_double_view +-gsl_matrix_long_double_view_array (long double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_double_view +-gsl_matrix_long_double_view_array_with_tda (long double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_long_double_view +-gsl_matrix_long_double_view_vector (gsl_vector_long_double * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_double_view +-gsl_matrix_long_double_view_vector_with_tda (gsl_vector_long_double * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_long_double_const_view +-gsl_matrix_long_double_const_submatrix (const gsl_matrix_long_double * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_row (const gsl_matrix_long_double * m, +- const size_t i); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_column (const gsl_matrix_long_double * m, +- const size_t j); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_diagonal (const gsl_matrix_long_double * m); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_subdiagonal (const gsl_matrix_long_double * m, +- const size_t k); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_superdiagonal (const gsl_matrix_long_double * m, +- const size_t k); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_subrow (const gsl_matrix_long_double * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_long_double_const_view +-gsl_matrix_long_double_const_subcolumn (const gsl_matrix_long_double * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_long_double_const_view +-gsl_matrix_long_double_const_view_array (const long double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_double_const_view +-gsl_matrix_long_double_const_view_array_with_tda (const long double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_long_double_const_view +-gsl_matrix_long_double_const_view_vector (const gsl_vector_long_double * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_double_const_view +-gsl_matrix_long_double_const_view_vector_with_tda (const gsl_vector_long_double * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_long_double_set_zero (gsl_matrix_long_double * m); +-void gsl_matrix_long_double_set_identity (gsl_matrix_long_double * m); +-void gsl_matrix_long_double_set_all (gsl_matrix_long_double * m, long double x); +- +-int gsl_matrix_long_double_fread (FILE * stream, gsl_matrix_long_double * m) ; +-int gsl_matrix_long_double_fwrite (FILE * stream, const gsl_matrix_long_double * m) ; +-int gsl_matrix_long_double_fscanf (FILE * stream, gsl_matrix_long_double * m); +-int gsl_matrix_long_double_fprintf (FILE * stream, const gsl_matrix_long_double * m, const char * format); +- +-int gsl_matrix_long_double_memcpy(gsl_matrix_long_double * dest, const gsl_matrix_long_double * src); +-int gsl_matrix_long_double_swap(gsl_matrix_long_double * m1, gsl_matrix_long_double * m2); +- +-int gsl_matrix_long_double_swap_rows(gsl_matrix_long_double * m, const size_t i, const size_t j); +-int gsl_matrix_long_double_swap_columns(gsl_matrix_long_double * m, const size_t i, const size_t j); +-int gsl_matrix_long_double_swap_rowcol(gsl_matrix_long_double * m, const size_t i, const size_t j); +-int gsl_matrix_long_double_transpose (gsl_matrix_long_double * m); +-int gsl_matrix_long_double_transpose_memcpy (gsl_matrix_long_double * dest, const gsl_matrix_long_double * src); +- +-long double gsl_matrix_long_double_max (const gsl_matrix_long_double * m); +-long double gsl_matrix_long_double_min (const gsl_matrix_long_double * m); +-void gsl_matrix_long_double_minmax (const gsl_matrix_long_double * m, long double * min_out, long double * max_out); +- +-void gsl_matrix_long_double_max_index (const gsl_matrix_long_double * m, size_t * imax, size_t *jmax); +-void gsl_matrix_long_double_min_index (const gsl_matrix_long_double * m, size_t * imin, size_t *jmin); +-void gsl_matrix_long_double_minmax_index (const gsl_matrix_long_double * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_long_double_equal (const gsl_matrix_long_double * a, const gsl_matrix_long_double * b); +- +-int gsl_matrix_long_double_isnull (const gsl_matrix_long_double * m); +-int gsl_matrix_long_double_ispos (const gsl_matrix_long_double * m); +-int gsl_matrix_long_double_isneg (const gsl_matrix_long_double * m); +-int gsl_matrix_long_double_isnonneg (const gsl_matrix_long_double * m); +- +-int gsl_matrix_long_double_add (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); +-int gsl_matrix_long_double_sub (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); +-int gsl_matrix_long_double_mul_elements (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); +-int gsl_matrix_long_double_div_elements (gsl_matrix_long_double * a, const gsl_matrix_long_double * b); +-int gsl_matrix_long_double_scale (gsl_matrix_long_double * a, const double x); +-int gsl_matrix_long_double_add_constant (gsl_matrix_long_double * a, const double x); +-int gsl_matrix_long_double_add_diagonal (gsl_matrix_long_double * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_long_double_get_row(gsl_vector_long_double * v, const gsl_matrix_long_double * m, const size_t i); +-int gsl_matrix_long_double_get_col(gsl_vector_long_double * v, const gsl_matrix_long_double * m, const size_t j); +-int gsl_matrix_long_double_set_row(gsl_matrix_long_double * m, const size_t i, const gsl_vector_long_double * v); +-int gsl_matrix_long_double_set_col(gsl_matrix_long_double * m, const size_t j, const gsl_vector_long_double * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL long double gsl_matrix_long_double_get(const gsl_matrix_long_double * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_long_double_set(gsl_matrix_long_double * m, const size_t i, const size_t j, const long double x); +-INLINE_DECL long double * gsl_matrix_long_double_ptr(gsl_matrix_long_double * m, const size_t i, const size_t j); +-INLINE_DECL const long double * gsl_matrix_long_double_const_ptr(const gsl_matrix_long_double * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-long double +-gsl_matrix_long_double_get(const gsl_matrix_long_double * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_long_double_set(gsl_matrix_long_double * m, const size_t i, const size_t j, const long double x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-long double * +-gsl_matrix_long_double_ptr(gsl_matrix_long_double * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (long double *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const long double * +-gsl_matrix_long_double_const_ptr(const gsl_matrix_long_double * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const long double *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_float.h (revision 14079) +@@ -1,99 +0,0 @@ +-/* statistics/gsl_statistics_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_FLOAT_H__ +-#define __GSL_STATISTICS_FLOAT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_float_mean (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_variance (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_sd (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_variance_with_fixed_mean (const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_sd_with_fixed_mean (const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_tss (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_tss_m (const float data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_float_absdev (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_skew (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_kurtosis (const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_lag1_autocorrelation (const float data[], const size_t stride, const size_t n); +- +-double gsl_stats_float_covariance (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n); +-double gsl_stats_float_correlation (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_float_variance_m (const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_sd_m (const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_absdev_m (const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_skew_m_sd (const float data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_float_kurtosis_m_sd (const float data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_float_lag1_autocorrelation_m (const float data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_float_covariance_m (const float data1[], const size_t stride1,const float data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +-/* DEFINED FOR FLOATING POINT TYPES ONLY */ +- +-double gsl_stats_float_wmean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wvariance (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wsd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wvariance_with_fixed_mean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_wsd_with_fixed_mean (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_float_wtss (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wtss_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_float_wabsdev (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wskew (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +-double gsl_stats_float_wkurtosis (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n); +- +-double gsl_stats_float_wvariance_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_float_wsd_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_float_wabsdev_m (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_float_wskew_m_sd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean, const double wsd); +-double gsl_stats_float_wkurtosis_m_sd (const float w[], const size_t wstride, const float data[], const size_t stride, const size_t n, const double wmean, const double wsd); +- +-/* END OF FLOATING POINT TYPES */ +- +-double gsl_stats_float_pvariance (const float data1[], const size_t stride1, const size_t n1, const float data2[], const size_t stride2, const size_t n2); +-double gsl_stats_float_ttest (const float data1[], const size_t stride1, const size_t n1, const float data2[], const size_t stride2, const size_t n2); +- +-float gsl_stats_float_max (const float data[], const size_t stride, const size_t n); +-float gsl_stats_float_min (const float data[], const size_t stride, const size_t n); +-void gsl_stats_float_minmax (float * min, float * max, const float data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_float_max_index (const float data[], const size_t stride, const size_t n); +-size_t gsl_stats_float_min_index (const float data[], const size_t stride, const size_t n); +-void gsl_stats_float_minmax_index (size_t * min_index, size_t * max_index, const float data[], const size_t stride, const size_t n); +- +-double gsl_stats_float_median_from_sorted_data (const float sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_float_quantile_from_sorted_data (const float sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_uint.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_UINT_H__ +-#define __GSL_PERMUTE_UINT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_uint (const size_t * p, unsigned int * data, const size_t stride, const size_t n); +-int gsl_permute_uint_inverse (const size_t * p, unsigned int * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_double.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_DOUBLE_H__ +-#define __GSL_SORT_DOUBLE_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort (double * data, const size_t stride, const size_t n); +-void gsl_sort_index (size_t * p, const double * data, const size_t stride, const size_t n); +- +-int gsl_sort_smallest (double * dest, const size_t k, const double * src, const size_t stride, const size_t n); +-int gsl_sort_smallest_index (size_t * p, const size_t k, const double * src, const size_t stride, const size_t n); +- +-int gsl_sort_largest (double * dest, const size_t k, const double * src, const size_t stride, const size_t n); +-int gsl_sort_largest_index (size_t * p, const size_t k, const double * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_double.h (revision 14079) +@@ -1,99 +0,0 @@ +-/* statistics/gsl_statistics_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_DOUBLE_H__ +-#define __GSL_STATISTICS_DOUBLE_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_mean (const double data[], const size_t stride, const size_t n); +-double gsl_stats_variance (const double data[], const size_t stride, const size_t n); +-double gsl_stats_sd (const double data[], const size_t stride, const size_t n); +-double gsl_stats_variance_with_fixed_mean (const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_sd_with_fixed_mean (const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_tss (const double data[], const size_t stride, const size_t n); +-double gsl_stats_tss_m (const double data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_absdev (const double data[], const size_t stride, const size_t n); +-double gsl_stats_skew (const double data[], const size_t stride, const size_t n); +-double gsl_stats_kurtosis (const double data[], const size_t stride, const size_t n); +-double gsl_stats_lag1_autocorrelation (const double data[], const size_t stride, const size_t n); +- +-double gsl_stats_covariance (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n); +-double gsl_stats_correlation (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_variance_m (const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_sd_m (const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_absdev_m (const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_skew_m_sd (const double data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_kurtosis_m_sd (const double data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_lag1_autocorrelation_m (const double data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_covariance_m (const double data1[], const size_t stride1,const double data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +-/* DEFINED FOR FLOATING POINT TYPES ONLY */ +- +-double gsl_stats_wmean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wvariance (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wsd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wvariance_with_fixed_mean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_wsd_with_fixed_mean (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_wtss (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wtss_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_wabsdev (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wskew (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +-double gsl_stats_wkurtosis (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n); +- +-double gsl_stats_wvariance_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_wsd_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_wabsdev_m (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_wskew_m_sd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean, const double wsd); +-double gsl_stats_wkurtosis_m_sd (const double w[], const size_t wstride, const double data[], const size_t stride, const size_t n, const double wmean, const double wsd); +- +-/* END OF FLOATING POINT TYPES */ +- +-double gsl_stats_pvariance (const double data1[], const size_t stride1, const size_t n1, const double data2[], const size_t stride2, const size_t n2); +-double gsl_stats_ttest (const double data1[], const size_t stride1, const size_t n1, const double data2[], const size_t stride2, const size_t n2); +- +-double gsl_stats_max (const double data[], const size_t stride, const size_t n); +-double gsl_stats_min (const double data[], const size_t stride, const size_t n); +-void gsl_stats_minmax (double * min, double * max, const double data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_max_index (const double data[], const size_t stride, const size_t n); +-size_t gsl_stats_min_index (const double data[], const size_t stride, const size_t n); +-void gsl_stats_minmax_index (size_t * min_index, size_t * max_index, const double data[], const size_t stride, const size_t n); +- +-double gsl_stats_median_from_sorted_data (const double sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_quantile_from_sorted_data (const double sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_exp.h (revision 14079) +@@ -1,134 +0,0 @@ +-/* specfunc/gsl_sf_exp.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_EXP_H__ +-#define __GSL_SF_EXP_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Provide an exp() function with GSL semantics, +- * i.e. with proper error checking, etc. +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_e(const double x, gsl_sf_result * result); +-double gsl_sf_exp(const double x); +- +- +-/* Exp(x) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_e10_e(const double x, gsl_sf_result_e10 * result); +- +- +-/* Exponentiate and multiply by a given factor: y * Exp(x) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_mult_e(const double x, const double y, gsl_sf_result * result); +-double gsl_sf_exp_mult(const double x, const double y); +- +- +-/* Exponentiate and multiply by a given factor: y * Exp(x) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_mult_e10_e(const double x, const double y, gsl_sf_result_e10 * result); +- +- +-/* exp(x)-1 +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_expm1_e(const double x, gsl_sf_result * result); +-double gsl_sf_expm1(const double x); +- +- +-/* (exp(x)-1)/x = 1 + x/2 + x^2/(2*3) + x^3/(2*3*4) + ... +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_exprel_e(const double x, gsl_sf_result * result); +-double gsl_sf_exprel(const double x); +- +- +-/* 2(exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(3*4) + x^3/(3*4*5) + ... +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_exprel_2_e(double x, gsl_sf_result * result); +-double gsl_sf_exprel_2(const double x); +- +- +-/* Similarly for the N-th generalization of +- * the above. The so-called N-relative exponential +- * +- * exprel_N(x) = N!/x^N (exp(x) - Sum[x^k/k!, {k,0,N-1}]) +- * = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ... +- * = 1F1(1,1+N,x) +- */ +-int gsl_sf_exprel_n_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_exprel_n(const int n, const double x); +- +-int gsl_sf_exprel_n_CF_e(const double n, const double x, gsl_sf_result * result); +- +- +-/* Exponentiate a quantity with an associated error. +- */ +-int gsl_sf_exp_err_e(const double x, const double dx, gsl_sf_result * result); +- +-/* Exponentiate a quantity with an associated error. +- */ +-int gsl_sf_exp_err_e10_e(const double x, const double dx, gsl_sf_result_e10 * result); +- +- +-/* Exponentiate and multiply by a given factor: y * Exp(x), +- * for quantities with associated errors. +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_mult_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result); +- +- +-/* Exponentiate and multiply by a given factor: y * Exp(x), +- * for quantities with associated errors. +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_exp_mult_err_e10_e(const double x, const double dx, const double y, const double dy, gsl_sf_result_e10 * result); +- +-__END_DECLS +- +-#endif /* __GSL_SF_EXP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_errno.h (revision 14079) +@@ -1,154 +0,0 @@ +-/* err/gsl_errno.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_ERRNO_H__ +-#define __GSL_ERRNO_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-enum { +- GSL_SUCCESS = 0, +- GSL_FAILURE = -1, +- GSL_CONTINUE = -2, /* iteration has not converged */ +- GSL_EDOM = 1, /* input domain error, e.g sqrt(-1) */ +- GSL_ERANGE = 2, /* output range error, e.g. exp(1e100) */ +- GSL_EFAULT = 3, /* invalid pointer */ +- GSL_EINVAL = 4, /* invalid argument supplied by user */ +- GSL_EFAILED = 5, /* generic failure */ +- GSL_EFACTOR = 6, /* factorization failed */ +- GSL_ESANITY = 7, /* sanity check failed - shouldn't happen */ +- GSL_ENOMEM = 8, /* malloc failed */ +- GSL_EBADFUNC = 9, /* problem with user-supplied function */ +- GSL_ERUNAWAY = 10, /* iterative process is out of control */ +- GSL_EMAXITER = 11, /* exceeded max number of iterations */ +- GSL_EZERODIV = 12, /* tried to divide by zero */ +- GSL_EBADTOL = 13, /* user specified an invalid tolerance */ +- GSL_ETOL = 14, /* failed to reach the specified tolerance */ +- GSL_EUNDRFLW = 15, /* underflow */ +- GSL_EOVRFLW = 16, /* overflow */ +- GSL_ELOSS = 17, /* loss of accuracy */ +- GSL_EROUND = 18, /* failed because of roundoff error */ +- GSL_EBADLEN = 19, /* matrix, vector lengths are not conformant */ +- GSL_ENOTSQR = 20, /* matrix not square */ +- GSL_ESING = 21, /* apparent singularity detected */ +- GSL_EDIVERGE = 22, /* integral or series is divergent */ +- GSL_EUNSUP = 23, /* requested feature is not supported by the hardware */ +- GSL_EUNIMPL = 24, /* requested feature not (yet) implemented */ +- GSL_ECACHE = 25, /* cache limit exceeded */ +- GSL_ETABLE = 26, /* table limit exceeded */ +- GSL_ENOPROG = 27, /* iteration is not making progress towards solution */ +- GSL_ENOPROGJ = 28, /* jacobian evaluations are not improving the solution */ +- GSL_ETOLF = 29, /* cannot reach the specified tolerance in F */ +- GSL_ETOLX = 30, /* cannot reach the specified tolerance in X */ +- GSL_ETOLG = 31, /* cannot reach the specified tolerance in gradient */ +- GSL_EOF = 32 /* end of file */ +-} ; +- +-void gsl_error (const char * reason, const char * file, int line, +- int gsl_errno); +- +-void gsl_stream_printf (const char *label, const char *file, +- int line, const char *reason); +- +-const char * gsl_strerror (const int gsl_errno); +- +-typedef void gsl_error_handler_t (const char * reason, const char * file, +- int line, int gsl_errno); +- +-typedef void gsl_stream_handler_t (const char * label, const char * file, +- int line, const char * reason); +- +-gsl_error_handler_t * +-gsl_set_error_handler (gsl_error_handler_t * new_handler); +- +-gsl_error_handler_t * +-gsl_set_error_handler_off (void); +- +-gsl_stream_handler_t * +-gsl_set_stream_handler (gsl_stream_handler_t * new_handler); +- +-FILE * gsl_set_stream (FILE * new_stream); +- +-/* GSL_ERROR: call the error handler, and return the error code */ +- +-#define GSL_ERROR(reason, gsl_errno) \ +- do { \ +- gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ +- return gsl_errno ; \ +- } while (0) +- +-/* GSL_ERROR_VAL: call the error handler, and return the given value */ +- +-#define GSL_ERROR_VAL(reason, gsl_errno, value) \ +- do { \ +- gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ +- return value ; \ +- } while (0) +- +-/* GSL_ERROR_VOID: call the error handler, and then return +- (for void functions which still need to generate an error) */ +- +-#define GSL_ERROR_VOID(reason, gsl_errno) \ +- do { \ +- gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ +- return ; \ +- } while (0) +- +-/* GSL_ERROR_NULL suitable for out-of-memory conditions */ +- +-#define GSL_ERROR_NULL(reason, gsl_errno) GSL_ERROR_VAL(reason, gsl_errno, 0) +- +-/* Sometimes you have several status results returned from +- * function calls and you want to combine them in some sensible +- * way. You cannot produce a "total" status condition, but you can +- * pick one from a set of conditions based on an implied hierarchy. +- * +- * In other words: +- * you have: status_a, status_b, ... +- * you want: status = (status_a if it is bad, or status_b if it is bad,...) +- * +- * In this example you consider status_a to be more important and +- * it is checked first, followed by the others in the order specified. +- * +- * Here are some dumb macros to do this. +- */ +-#define GSL_ERROR_SELECT_2(a,b) ((a) != GSL_SUCCESS ? (a) : ((b) != GSL_SUCCESS ? (b) : GSL_SUCCESS)) +-#define GSL_ERROR_SELECT_3(a,b,c) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_2(b,c)) +-#define GSL_ERROR_SELECT_4(a,b,c,d) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_3(b,c,d)) +-#define GSL_ERROR_SELECT_5(a,b,c,d,e) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_4(b,c,d,e)) +- +-#define GSL_STATUS_UPDATE(sp, s) do { if ((s) != GSL_SUCCESS) *(sp) = (s);} while(0) +- +-__END_DECLS +- +-#endif /* __GSL_ERRNO_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ulong.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_ULONG_H__ +-#define __GSL_PERMUTE_ULONG_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_ulong (const size_t * p, unsigned long * data, const size_t stride, const size_t n); +-int gsl_permute_ulong_inverse (const size_t * p, unsigned long * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex_float.h (revision 14079) +@@ -1,55 +0,0 @@ +-/* fft/gsl_dft_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_DFT_COMPLEX_FLOAT_H__ +-#define __GSL_DFT_COMPLEX_FLOAT_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_dft_complex_float_forward (const float data[], const size_t stride, const size_t n, +- float result[]); +- +-int gsl_dft_complex_float_backward (const float data[], const size_t stride, const size_t n, +- float result[]); +- +-int gsl_dft_complex_float_inverse (const float data[], const size_t stride, const size_t n, +- float result[]); +- +-int gsl_dft_complex_float_transform (const float data[], const size_t stride, const size_t n, +- float result[], const gsl_fft_direction sign); +- +-__END_DECLS +- +-#endif /* __GSL_DFT_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_float.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_FLOAT_H__ +-#define __GSL_MATRIX_FLOAT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- float * data; +- gsl_block_float * block; +- int owner; +-} gsl_matrix_float; +- +-typedef struct +-{ +- gsl_matrix_float matrix; +-} _gsl_matrix_float_view; +- +-typedef _gsl_matrix_float_view gsl_matrix_float_view; +- +-typedef struct +-{ +- gsl_matrix_float matrix; +-} _gsl_matrix_float_const_view; +- +-typedef const _gsl_matrix_float_const_view gsl_matrix_float_const_view; +- +-/* Allocation */ +- +-gsl_matrix_float * +-gsl_matrix_float_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_float * +-gsl_matrix_float_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_float * +-gsl_matrix_float_alloc_from_block (gsl_block_float * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_float * +-gsl_matrix_float_alloc_from_matrix (gsl_matrix_float * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_float * +-gsl_vector_float_alloc_row_from_matrix (gsl_matrix_float * m, +- const size_t i); +- +-gsl_vector_float * +-gsl_vector_float_alloc_col_from_matrix (gsl_matrix_float * m, +- const size_t j); +- +-void gsl_matrix_float_free (gsl_matrix_float * m); +- +-/* Views */ +- +-_gsl_matrix_float_view +-gsl_matrix_float_submatrix (gsl_matrix_float * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_float_view +-gsl_matrix_float_row (gsl_matrix_float * m, const size_t i); +- +-_gsl_vector_float_view +-gsl_matrix_float_column (gsl_matrix_float * m, const size_t j); +- +-_gsl_vector_float_view +-gsl_matrix_float_diagonal (gsl_matrix_float * m); +- +-_gsl_vector_float_view +-gsl_matrix_float_subdiagonal (gsl_matrix_float * m, const size_t k); +- +-_gsl_vector_float_view +-gsl_matrix_float_superdiagonal (gsl_matrix_float * m, const size_t k); +- +-_gsl_vector_float_view +-gsl_matrix_float_subrow (gsl_matrix_float * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_float_view +-gsl_matrix_float_subcolumn (gsl_matrix_float * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_float_view +-gsl_matrix_float_view_array (float * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_float_view +-gsl_matrix_float_view_array_with_tda (float * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_float_view +-gsl_matrix_float_view_vector (gsl_vector_float * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_float_view +-gsl_matrix_float_view_vector_with_tda (gsl_vector_float * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_float_const_view +-gsl_matrix_float_const_submatrix (const gsl_matrix_float * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_row (const gsl_matrix_float * m, +- const size_t i); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_column (const gsl_matrix_float * m, +- const size_t j); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_diagonal (const gsl_matrix_float * m); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_subdiagonal (const gsl_matrix_float * m, +- const size_t k); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_superdiagonal (const gsl_matrix_float * m, +- const size_t k); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_subrow (const gsl_matrix_float * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_float_const_view +-gsl_matrix_float_const_subcolumn (const gsl_matrix_float * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_float_const_view +-gsl_matrix_float_const_view_array (const float * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_float_const_view +-gsl_matrix_float_const_view_array_with_tda (const float * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_float_const_view +-gsl_matrix_float_const_view_vector (const gsl_vector_float * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_float_const_view +-gsl_matrix_float_const_view_vector_with_tda (const gsl_vector_float * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_float_set_zero (gsl_matrix_float * m); +-void gsl_matrix_float_set_identity (gsl_matrix_float * m); +-void gsl_matrix_float_set_all (gsl_matrix_float * m, float x); +- +-int gsl_matrix_float_fread (FILE * stream, gsl_matrix_float * m) ; +-int gsl_matrix_float_fwrite (FILE * stream, const gsl_matrix_float * m) ; +-int gsl_matrix_float_fscanf (FILE * stream, gsl_matrix_float * m); +-int gsl_matrix_float_fprintf (FILE * stream, const gsl_matrix_float * m, const char * format); +- +-int gsl_matrix_float_memcpy(gsl_matrix_float * dest, const gsl_matrix_float * src); +-int gsl_matrix_float_swap(gsl_matrix_float * m1, gsl_matrix_float * m2); +- +-int gsl_matrix_float_swap_rows(gsl_matrix_float * m, const size_t i, const size_t j); +-int gsl_matrix_float_swap_columns(gsl_matrix_float * m, const size_t i, const size_t j); +-int gsl_matrix_float_swap_rowcol(gsl_matrix_float * m, const size_t i, const size_t j); +-int gsl_matrix_float_transpose (gsl_matrix_float * m); +-int gsl_matrix_float_transpose_memcpy (gsl_matrix_float * dest, const gsl_matrix_float * src); +- +-float gsl_matrix_float_max (const gsl_matrix_float * m); +-float gsl_matrix_float_min (const gsl_matrix_float * m); +-void gsl_matrix_float_minmax (const gsl_matrix_float * m, float * min_out, float * max_out); +- +-void gsl_matrix_float_max_index (const gsl_matrix_float * m, size_t * imax, size_t *jmax); +-void gsl_matrix_float_min_index (const gsl_matrix_float * m, size_t * imin, size_t *jmin); +-void gsl_matrix_float_minmax_index (const gsl_matrix_float * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_float_equal (const gsl_matrix_float * a, const gsl_matrix_float * b); +- +-int gsl_matrix_float_isnull (const gsl_matrix_float * m); +-int gsl_matrix_float_ispos (const gsl_matrix_float * m); +-int gsl_matrix_float_isneg (const gsl_matrix_float * m); +-int gsl_matrix_float_isnonneg (const gsl_matrix_float * m); +- +-int gsl_matrix_float_add (gsl_matrix_float * a, const gsl_matrix_float * b); +-int gsl_matrix_float_sub (gsl_matrix_float * a, const gsl_matrix_float * b); +-int gsl_matrix_float_mul_elements (gsl_matrix_float * a, const gsl_matrix_float * b); +-int gsl_matrix_float_div_elements (gsl_matrix_float * a, const gsl_matrix_float * b); +-int gsl_matrix_float_scale (gsl_matrix_float * a, const double x); +-int gsl_matrix_float_add_constant (gsl_matrix_float * a, const double x); +-int gsl_matrix_float_add_diagonal (gsl_matrix_float * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_float_get_row(gsl_vector_float * v, const gsl_matrix_float * m, const size_t i); +-int gsl_matrix_float_get_col(gsl_vector_float * v, const gsl_matrix_float * m, const size_t j); +-int gsl_matrix_float_set_row(gsl_matrix_float * m, const size_t i, const gsl_vector_float * v); +-int gsl_matrix_float_set_col(gsl_matrix_float * m, const size_t j, const gsl_vector_float * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL float gsl_matrix_float_get(const gsl_matrix_float * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_float_set(gsl_matrix_float * m, const size_t i, const size_t j, const float x); +-INLINE_DECL float * gsl_matrix_float_ptr(gsl_matrix_float * m, const size_t i, const size_t j); +-INLINE_DECL const float * gsl_matrix_float_const_ptr(const gsl_matrix_float * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-float +-gsl_matrix_float_get(const gsl_matrix_float * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_float_set(gsl_matrix_float * m, const size_t i, const size_t j, const float x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-float * +-gsl_matrix_float_ptr(gsl_matrix_float * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (float *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const float * +-gsl_matrix_float_const_ptr(const gsl_matrix_float * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const float *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_math.h (revision 14079) +@@ -1,164 +0,0 @@ +-/* gsl_math.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATH_H__ +-#define __GSL_MATH_H__ +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#ifndef M_E +-#define M_E 2.71828182845904523536028747135 /* e */ +-#endif +- +-#ifndef M_LOG2E +-#define M_LOG2E 1.44269504088896340735992468100 /* log_2 (e) */ +-#endif +- +-#ifndef M_LOG10E +-#define M_LOG10E 0.43429448190325182765112891892 /* log_10 (e) */ +-#endif +- +-#ifndef M_SQRT2 +-#define M_SQRT2 1.41421356237309504880168872421 /* sqrt(2) */ +-#endif +- +-#ifndef M_SQRT1_2 +-#define M_SQRT1_2 0.70710678118654752440084436210 /* sqrt(1/2) */ +-#endif +- +- +-#ifndef M_SQRT3 +-#define M_SQRT3 1.73205080756887729352744634151 /* sqrt(3) */ +-#endif +- +-#ifndef M_PI +-#define M_PI 3.14159265358979323846264338328 /* pi */ +-#endif +- +-#ifndef M_PI_2 +-#define M_PI_2 1.57079632679489661923132169164 /* pi/2 */ +-#endif +- +-#ifndef M_PI_4 +-#define M_PI_4 0.78539816339744830961566084582 /* pi/4 */ +-#endif +- +-#ifndef M_SQRTPI +-#define M_SQRTPI 1.77245385090551602729816748334 /* sqrt(pi) */ +-#endif +- +-#ifndef M_2_SQRTPI +-#define M_2_SQRTPI 1.12837916709551257389615890312 /* 2/sqrt(pi) */ +-#endif +- +-#ifndef M_1_PI +-#define M_1_PI 0.31830988618379067153776752675 /* 1/pi */ +-#endif +- +-#ifndef M_2_PI +-#define M_2_PI 0.63661977236758134307553505349 /* 2/pi */ +-#endif +- +-#ifndef M_LN10 +-#define M_LN10 2.30258509299404568401799145468 /* ln(10) */ +-#endif +- +-#ifndef M_LN2 +-#define M_LN2 0.69314718055994530941723212146 /* ln(2) */ +-#endif +- +-#ifndef M_LNPI +-#define M_LNPI 1.14472988584940017414342735135 /* ln(pi) */ +-#endif +- +-#ifndef M_EULER +-#define M_EULER 0.57721566490153286060651209008 /* Euler constant */ +-#endif +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* other needlessly compulsive abstractions */ +- +-#define GSL_IS_ODD(n) ((n) & 1) +-#define GSL_IS_EVEN(n) (!(GSL_IS_ODD(n))) +-#define GSL_SIGN(x) ((x) >= 0.0 ? 1 : -1) +- +-/* Return nonzero if x is a real number, i.e. non NaN or infinite. */ +-#define GSL_IS_REAL(x) (gsl_finite(x)) +- +-/* Definition of an arbitrary function with parameters */ +- +-struct gsl_function_struct +-{ +- double (* function) (double x, void * params); +- void * params; +-}; +- +-typedef struct gsl_function_struct gsl_function ; +- +-#define GSL_FN_EVAL(F,x) (*((F)->function))(x,(F)->params) +- +-/* Definition of an arbitrary function returning two values, r1, r2 */ +- +-struct gsl_function_fdf_struct +-{ +- double (* f) (double x, void * params); +- double (* df) (double x, void * params); +- void (* fdf) (double x, void * params, double * f, double * df); +- void * params; +-}; +- +-typedef struct gsl_function_fdf_struct gsl_function_fdf ; +- +-#define GSL_FN_FDF_EVAL_F(FDF,x) (*((FDF)->f))(x,(FDF)->params) +-#define GSL_FN_FDF_EVAL_DF(FDF,x) (*((FDF)->df))(x,(FDF)->params) +-#define GSL_FN_FDF_EVAL_F_DF(FDF,x,y,dy) (*((FDF)->fdf))(x,(FDF)->params,(y),(dy)) +- +- +-/* Definition of an arbitrary vector-valued function with parameters */ +- +-struct gsl_function_vec_struct +-{ +- int (* function) (double x, double y[], void * params); +- void * params; +-}; +- +-typedef struct gsl_function_vec_struct gsl_function_vec ; +- +-#define GSL_FN_VEC_EVAL(F,x,y) (*((F)->function))(x,y,(F)->params) +- +-__END_DECLS +- +-#endif /* __GSL_MATH_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex.h (revision 14079) +@@ -1,17 +0,0 @@ +-#ifndef __GSL_VECTOR_COMPLEX_H__ +-#define __GSL_VECTOR_COMPLEX_H__ +- +-#define GSL_VECTOR_REAL(z, i) ((z)->data[2*(i)*(z)->stride]) +-#define GSL_VECTOR_IMAG(z, i) ((z)->data[2*(i)*(z)->stride + 1]) +- +-#if GSL_RANGE_CHECK +-#define GSL_VECTOR_COMPLEX(zv, i) (((i) >= (zv)->size ? (gsl_error ("index out of range", __FILE__, __LINE__, GSL_EINVAL), 0):0 , *GSL_COMPLEX_AT((zv),(i)))) +-#else +-#define GSL_VECTOR_COMPLEX(zv, i) (*GSL_COMPLEX_AT((zv),(i))) +-#endif +- +-#define GSL_COMPLEX_AT(zv,i) ((gsl_complex*)&((zv)->data[2*(i)*(zv)->stride])) +-#define GSL_COMPLEX_FLOAT_AT(zv,i) ((gsl_complex_float*)&((zv)->data[2*(i)*(zv)->stride])) +-#define GSL_COMPLEX_LONG_DOUBLE_AT(zv,i) ((gsl_complex_long_double*)&((zv)->data[2*(i)*(zv)->stride])) +- +-#endif /* __GSL_VECTOR_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_zeta.h (revision 14079) +@@ -1,112 +0,0 @@ +-/* specfunc/gsl_sf_zeta.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_ZETA_H__ +-#define __GSL_SF_ZETA_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Riemann Zeta Function +- * zeta(n) = Sum[ k^(-n), {k,1,Infinity} ] +- * +- * n=integer, n != 1 +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_zeta_int_e(const int n, gsl_sf_result * result); +-double gsl_sf_zeta_int(const int n); +- +- +-/* Riemann Zeta Function +- * zeta(x) = Sum[ k^(-s), {k,1,Infinity} ], s != 1.0 +- * +- * s != 1.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_zeta_e(const double s, gsl_sf_result * result); +-double gsl_sf_zeta(const double s); +- +- +-/* Riemann Zeta Function minus 1 +- * useful for evaluating the fractional part +- * of Riemann zeta for large argument +- * +- * s != 1.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_zetam1_e(const double s, gsl_sf_result * result); +-double gsl_sf_zetam1(const double s); +- +- +-/* Riemann Zeta Function minus 1 for integer arg +- * useful for evaluating the fractional part +- * of Riemann zeta for large argument +- * +- * s != 1.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_zetam1_int_e(const int s, gsl_sf_result * result); +-double gsl_sf_zetam1_int(const int s); +- +- +-/* Hurwitz Zeta Function +- * zeta(s,q) = Sum[ (k+q)^(-s), {k,0,Infinity} ] +- * +- * s > 1.0, q > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_hzeta_e(const double s, const double q, gsl_sf_result * result); +-double gsl_sf_hzeta(const double s, const double q); +- +- +-/* Eta Function +- * eta(n) = (1-2^(1-n)) zeta(n) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_eta_int_e(int n, gsl_sf_result * result); +-double gsl_sf_eta_int(const int n); +- +- +-/* Eta Function +- * eta(s) = (1-2^(1-s)) zeta(s) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_eta_e(const double s, gsl_sf_result * result); +-double gsl_sf_eta(const double s); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_ZETA_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram.h (revision 14079) +@@ -1,134 +0,0 @@ +-/* histogram/gsl_histogram.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_HISTOGRAM_H__ +-#define __GSL_HISTOGRAM_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- size_t n ; +- double * range ; +- double * bin ; +-} gsl_histogram ; +- +-typedef struct { +- size_t n ; +- double * range ; +- double * sum ; +-} gsl_histogram_pdf ; +- +-gsl_histogram * gsl_histogram_alloc (size_t n); +- +-gsl_histogram * gsl_histogram_calloc (size_t n); +-gsl_histogram * gsl_histogram_calloc_uniform (const size_t n, const double xmin, const double xmax); +-void gsl_histogram_free (gsl_histogram * h); +-int gsl_histogram_increment (gsl_histogram * h, double x); +-int gsl_histogram_accumulate (gsl_histogram * h, double x, double weight); +-int gsl_histogram_find (const gsl_histogram * h, +- const double x, size_t * i); +- +-double gsl_histogram_get (const gsl_histogram * h, size_t i); +-int gsl_histogram_get_range (const gsl_histogram * h, size_t i, +- double * lower, double * upper); +- +-double gsl_histogram_max (const gsl_histogram * h); +-double gsl_histogram_min (const gsl_histogram * h); +-size_t gsl_histogram_bins (const gsl_histogram * h); +- +-void gsl_histogram_reset (gsl_histogram * h); +- +-gsl_histogram * gsl_histogram_calloc_range(size_t n, double * range); +- +-int +-gsl_histogram_set_ranges (gsl_histogram * h, const double range[], size_t size); +-int +-gsl_histogram_set_ranges_uniform (gsl_histogram * h, double xmin, double xmax); +- +- +- +-int +-gsl_histogram_memcpy(gsl_histogram * dest, const gsl_histogram * source); +- +-gsl_histogram * +-gsl_histogram_clone(const gsl_histogram * source); +- +-double gsl_histogram_max_val (const gsl_histogram * h); +- +-size_t gsl_histogram_max_bin (const gsl_histogram * h); +- +-double gsl_histogram_min_val (const gsl_histogram * h); +- +-size_t gsl_histogram_min_bin (const gsl_histogram * h); +- +-int +-gsl_histogram_equal_bins_p(const gsl_histogram *h1, const gsl_histogram *h2); +- +-int +-gsl_histogram_add(gsl_histogram *h1, const gsl_histogram *h2); +- +-int +-gsl_histogram_sub(gsl_histogram *h1, const gsl_histogram *h2); +- +-int +-gsl_histogram_mul(gsl_histogram *h1, const gsl_histogram *h2); +- +-int +-gsl_histogram_div(gsl_histogram *h1, const gsl_histogram *h2); +- +-int +-gsl_histogram_scale(gsl_histogram *h, double scale); +- +-int +-gsl_histogram_shift (gsl_histogram * h, double shift); +- +- +-double gsl_histogram_sigma (const gsl_histogram * h); +- +-double gsl_histogram_mean (const gsl_histogram * h); +- +-double gsl_histogram_sum (const gsl_histogram * h); +- +-int gsl_histogram_fwrite (FILE * stream, const gsl_histogram * h) ; +-int gsl_histogram_fread (FILE * stream, gsl_histogram * h); +-int gsl_histogram_fprintf (FILE * stream, const gsl_histogram * h, +- const char * range_format, const char * bin_format); +-int gsl_histogram_fscanf (FILE * stream, gsl_histogram * h); +- +-gsl_histogram_pdf * gsl_histogram_pdf_alloc (const size_t n); +-int gsl_histogram_pdf_init (gsl_histogram_pdf * p, const gsl_histogram * h); +-void gsl_histogram_pdf_free (gsl_histogram_pdf * p); +-double gsl_histogram_pdf_sample (const gsl_histogram_pdf * p, double r); +- +-__END_DECLS +- +-#endif /* __GSL_HISTOGRAM_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet2d.h (revision 14079) +@@ -1,107 +0,0 @@ +-/* wavelet/gsl_wavelet.h +- * +- * Copyright (C) 2004 Ivo Alxneit +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_WAVELET2D_H__ +-#define __GSL_WAVELET2D_H__ +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_wavelet2d_transform (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_direction dir, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet2d_transform_forward (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet2d_transform_inverse (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet2d_nstransform (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_direction dir, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet2d_nstransform_forward (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet2d_nstransform_inverse (const gsl_wavelet * w, +- double *data, +- size_t tda, size_t size1, size_t size2, +- gsl_wavelet_workspace * work); +- +-int +-gsl_wavelet2d_transform_matrix (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_direction dir, +- gsl_wavelet_workspace * work); +- +-int +-gsl_wavelet2d_transform_matrix_forward (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_workspace * work); +- +-int +-gsl_wavelet2d_transform_matrix_inverse (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_workspace * work); +- +- +-int +-gsl_wavelet2d_nstransform_matrix (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_direction dir, +- gsl_wavelet_workspace * work); +- +-int +-gsl_wavelet2d_nstransform_matrix_forward (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_workspace * work); +- +-int +-gsl_wavelet2d_nstransform_matrix_inverse (const gsl_wavelet * w, +- gsl_matrix * a, +- gsl_wavelet_workspace * work); +- +-__END_DECLS +- +-#endif /* __GSL_WAVELET2D_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_char.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_CHAR_H__ +-#define __GSL_VECTOR_CHAR_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- char *data; +- gsl_block_char *block; +- int owner; +-} +-gsl_vector_char; +- +-typedef struct +-{ +- gsl_vector_char vector; +-} _gsl_vector_char_view; +- +-typedef _gsl_vector_char_view gsl_vector_char_view; +- +-typedef struct +-{ +- gsl_vector_char vector; +-} _gsl_vector_char_const_view; +- +-typedef const _gsl_vector_char_const_view gsl_vector_char_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_char *gsl_vector_char_alloc (const size_t n); +-gsl_vector_char *gsl_vector_char_calloc (const size_t n); +- +-gsl_vector_char *gsl_vector_char_alloc_from_block (gsl_block_char * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_char *gsl_vector_char_alloc_from_vector (gsl_vector_char * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_char_free (gsl_vector_char * v); +- +-/* Views */ +- +-_gsl_vector_char_view +-gsl_vector_char_view_array (char *v, size_t n); +- +-_gsl_vector_char_view +-gsl_vector_char_view_array_with_stride (char *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_char_const_view +-gsl_vector_char_const_view_array (const char *v, size_t n); +- +-_gsl_vector_char_const_view +-gsl_vector_char_const_view_array_with_stride (const char *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_char_view +-gsl_vector_char_subvector (gsl_vector_char *v, +- size_t i, +- size_t n); +- +-_gsl_vector_char_view +-gsl_vector_char_subvector_with_stride (gsl_vector_char *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_char_const_view +-gsl_vector_char_const_subvector (const gsl_vector_char *v, +- size_t i, +- size_t n); +- +-_gsl_vector_char_const_view +-gsl_vector_char_const_subvector_with_stride (const gsl_vector_char *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_char_set_zero (gsl_vector_char * v); +-void gsl_vector_char_set_all (gsl_vector_char * v, char x); +-int gsl_vector_char_set_basis (gsl_vector_char * v, size_t i); +- +-int gsl_vector_char_fread (FILE * stream, gsl_vector_char * v); +-int gsl_vector_char_fwrite (FILE * stream, const gsl_vector_char * v); +-int gsl_vector_char_fscanf (FILE * stream, gsl_vector_char * v); +-int gsl_vector_char_fprintf (FILE * stream, const gsl_vector_char * v, +- const char *format); +- +-int gsl_vector_char_memcpy (gsl_vector_char * dest, const gsl_vector_char * src); +- +-int gsl_vector_char_reverse (gsl_vector_char * v); +- +-int gsl_vector_char_swap (gsl_vector_char * v, gsl_vector_char * w); +-int gsl_vector_char_swap_elements (gsl_vector_char * v, const size_t i, const size_t j); +- +-char gsl_vector_char_max (const gsl_vector_char * v); +-char gsl_vector_char_min (const gsl_vector_char * v); +-void gsl_vector_char_minmax (const gsl_vector_char * v, char * min_out, char * max_out); +- +-size_t gsl_vector_char_max_index (const gsl_vector_char * v); +-size_t gsl_vector_char_min_index (const gsl_vector_char * v); +-void gsl_vector_char_minmax_index (const gsl_vector_char * v, size_t * imin, size_t * imax); +- +-int gsl_vector_char_add (gsl_vector_char * a, const gsl_vector_char * b); +-int gsl_vector_char_sub (gsl_vector_char * a, const gsl_vector_char * b); +-int gsl_vector_char_mul (gsl_vector_char * a, const gsl_vector_char * b); +-int gsl_vector_char_div (gsl_vector_char * a, const gsl_vector_char * b); +-int gsl_vector_char_scale (gsl_vector_char * a, const double x); +-int gsl_vector_char_add_constant (gsl_vector_char * a, const double x); +- +-int gsl_vector_char_equal (const gsl_vector_char * u, +- const gsl_vector_char * v); +- +-int gsl_vector_char_isnull (const gsl_vector_char * v); +-int gsl_vector_char_ispos (const gsl_vector_char * v); +-int gsl_vector_char_isneg (const gsl_vector_char * v); +-int gsl_vector_char_isnonneg (const gsl_vector_char * v); +- +-INLINE_DECL char gsl_vector_char_get (const gsl_vector_char * v, const size_t i); +-INLINE_DECL void gsl_vector_char_set (gsl_vector_char * v, const size_t i, char x); +-INLINE_DECL char * gsl_vector_char_ptr (gsl_vector_char * v, const size_t i); +-INLINE_DECL const char * gsl_vector_char_const_ptr (const gsl_vector_char * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-char +-gsl_vector_char_get (const gsl_vector_char * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_char_set (gsl_vector_char * v, const size_t i, char x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-char * +-gsl_vector_char_ptr (gsl_vector_char * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (char *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const char * +-gsl_vector_char_const_ptr (const gsl_vector_char * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const char *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_CHAR_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_long.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_LONG_H__ +-#define __GSL_PERMUTE_LONG_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_long (const size_t * p, long * data, const size_t stride, const size_t n); +-int gsl_permute_long_inverse (const size_t * p, long * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_char.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_CHAR_H__ +-#define __GSL_PERMUTE_VECTOR_CHAR_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_char (const gsl_permutation * p, gsl_vector_char * v); +-int gsl_permute_vector_char_inverse (const gsl_permutation * p, gsl_vector_char * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_complex_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_COMPLEX_DOUBLE_H__ +-#define __GSL_PERMUTE_COMPLEX_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_complex (const size_t * p, double * data, const size_t stride, const size_t n); +-int gsl_permute_complex_inverse (const size_t * p, double * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector.h (revision 14079) +@@ -1,25 +0,0 @@ +-#ifndef __GSL_VECTOR_H__ +-#define __GSL_VECTOR_H__ +- +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +- +-#endif /* __GSL_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_double.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_DOUBLE_H__ +-#define __GSL_SORT_VECTOR_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector (gsl_vector * v); +-int gsl_sort_vector_index (gsl_permutation * p, const gsl_vector * v); +- +-int gsl_sort_vector_smallest (double * dest, const size_t k, const gsl_vector * v); +-int gsl_sort_vector_largest (double * dest, const size_t k, const gsl_vector * v); +- +-int gsl_sort_vector_smallest_index (size_t * p, const size_t k, const gsl_vector * v); +-int gsl_sort_vector_largest_index (size_t * p, const size_t k, const gsl_vector * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_machine.h (revision 14079) +@@ -1,104 +0,0 @@ +-/* Author: B. Gough and G. Jungman */ +-#ifndef __GSL_MACHINE_H__ +-#define __GSL_MACHINE_H__ +- +-#include +-#include +- +-/* magic constants; mostly for the benefit of the implementation */ +- +-/* -*-MACHINE CONSTANTS-*- +- * +- * PLATFORM: Whiz-O-Matic 9000 +- * FP_PLATFORM: IEEE-Virtual +- * HOSTNAME: nnn.lanl.gov +- * DATE: Fri Nov 20 17:53:26 MST 1998 +- */ +-#define GSL_DBL_EPSILON 2.2204460492503131e-16 +-#define GSL_SQRT_DBL_EPSILON 1.4901161193847656e-08 +-#define GSL_ROOT3_DBL_EPSILON 6.0554544523933429e-06 +-#define GSL_ROOT4_DBL_EPSILON 1.2207031250000000e-04 +-#define GSL_ROOT5_DBL_EPSILON 7.4009597974140505e-04 +-#define GSL_ROOT6_DBL_EPSILON 2.4607833005759251e-03 +-#define GSL_LOG_DBL_EPSILON (-3.6043653389117154e+01) +- +-#define GSL_DBL_MIN 2.2250738585072014e-308 +-#define GSL_SQRT_DBL_MIN 1.4916681462400413e-154 +-#define GSL_ROOT3_DBL_MIN 2.8126442852362996e-103 +-#define GSL_ROOT4_DBL_MIN 1.2213386697554620e-77 +-#define GSL_ROOT5_DBL_MIN 2.9476022969691763e-62 +-#define GSL_ROOT6_DBL_MIN 5.3034368905798218e-52 +-#define GSL_LOG_DBL_MIN (-7.0839641853226408e+02) +- +-#define GSL_DBL_MAX 1.7976931348623157e+308 +-#define GSL_SQRT_DBL_MAX 1.3407807929942596e+154 +-#define GSL_ROOT3_DBL_MAX 5.6438030941222897e+102 +-#define GSL_ROOT4_DBL_MAX 1.1579208923731620e+77 +-#define GSL_ROOT5_DBL_MAX 4.4765466227572707e+61 +-#define GSL_ROOT6_DBL_MAX 2.3756689782295612e+51 +-#define GSL_LOG_DBL_MAX 7.0978271289338397e+02 +- +-#define GSL_FLT_EPSILON 1.1920928955078125e-07 +-#define GSL_SQRT_FLT_EPSILON 3.4526698300124393e-04 +-#define GSL_ROOT3_FLT_EPSILON 4.9215666011518501e-03 +-#define GSL_ROOT4_FLT_EPSILON 1.8581361171917516e-02 +-#define GSL_ROOT5_FLT_EPSILON 4.1234622211652937e-02 +-#define GSL_ROOT6_FLT_EPSILON 7.0153878019335827e-02 +-#define GSL_LOG_FLT_EPSILON (-1.5942385152878742e+01) +- +-#define GSL_FLT_MIN 1.1754943508222875e-38 +-#define GSL_SQRT_FLT_MIN 1.0842021724855044e-19 +-#define GSL_ROOT3_FLT_MIN 2.2737367544323241e-13 +-#define GSL_ROOT4_FLT_MIN 3.2927225399135965e-10 +-#define GSL_ROOT5_FLT_MIN 2.5944428542140822e-08 +-#define GSL_ROOT6_FLT_MIN 4.7683715820312542e-07 +-#define GSL_LOG_FLT_MIN (-8.7336544750553102e+01) +- +-#define GSL_FLT_MAX 3.4028234663852886e+38 +-#define GSL_SQRT_FLT_MAX 1.8446743523953730e+19 +-#define GSL_ROOT3_FLT_MAX 6.9814635196223242e+12 +-#define GSL_ROOT4_FLT_MAX 4.2949672319999986e+09 +-#define GSL_ROOT5_FLT_MAX 5.0859007855960041e+07 +-#define GSL_ROOT6_FLT_MAX 2.6422459233807749e+06 +-#define GSL_LOG_FLT_MAX 8.8722839052068352e+01 +- +-#define GSL_SFLT_EPSILON 4.8828125000000000e-04 +-#define GSL_SQRT_SFLT_EPSILON 2.2097086912079612e-02 +-#define GSL_ROOT3_SFLT_EPSILON 7.8745065618429588e-02 +-#define GSL_ROOT4_SFLT_EPSILON 1.4865088937534013e-01 +-#define GSL_ROOT5_SFLT_EPSILON 2.1763764082403100e-01 +-#define GSL_ROOT6_SFLT_EPSILON 2.8061551207734325e-01 +-#define GSL_LOG_SFLT_EPSILON (-7.6246189861593985e+00) +- +-/* !MACHINE CONSTANTS! */ +- +- +-/* a little internal backwards compatibility */ +-#define GSL_MACH_EPS GSL_DBL_EPSILON +- +- +- +-/* Here are the constants related to or derived from +- * machine constants. These are not to be confused with +- * the constants that define various precision levels +- * for the precision/error system. +- * +- * This information is determined at configure time +- * and is platform dependent. Edit at your own risk. +- * +- * PLATFORM: WHIZ-O-MATIC +- * CONFIG-DATE: Thu Nov 19 19:27:18 MST 1998 +- * CONFIG-HOST: nnn.lanl.gov +- */ +- +-/* machine precision constants */ +-/* #define GSL_MACH_EPS 1.0e-15 */ +-#define GSL_SQRT_MACH_EPS 3.2e-08 +-#define GSL_ROOT3_MACH_EPS 1.0e-05 +-#define GSL_ROOT4_MACH_EPS 0.000178 +-#define GSL_ROOT5_MACH_EPS 0.00100 +-#define GSL_ROOT6_MACH_EPS 0.00316 +-#define GSL_LOG_MACH_EPS (-34.54) +- +- +-#endif /* __GSL_MACHINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_dft_complex.h (revision 14079) +@@ -1,55 +0,0 @@ +-/* fft/gsl_dft_complex.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_DFT_COMPLEX_H__ +-#define __GSL_DFT_COMPLEX_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_dft_complex_forward (const double data[], const size_t stride, const size_t n, +- double result[]); +- +-int gsl_dft_complex_backward (const double data[], const size_t stride, const size_t n, +- double result[]); +- +-int gsl_dft_complex_inverse (const double data[], const size_t stride, const size_t n, +- double result[]); +- +-int gsl_dft_complex_transform (const double data[], const size_t stride, const size_t n, +- double result[], const gsl_fft_direction sign); +- +-__END_DECLS +- +-#endif /* __GSL_DFT_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_int.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_INT_H__ +-#define __GSL_BLOCK_INT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_int_struct +-{ +- size_t size; +- int *data; +-}; +- +-typedef struct gsl_block_int_struct gsl_block_int; +- +-gsl_block_int *gsl_block_int_alloc (const size_t n); +-gsl_block_int *gsl_block_int_calloc (const size_t n); +-void gsl_block_int_free (gsl_block_int * b); +- +-int gsl_block_int_fread (FILE * stream, gsl_block_int * b); +-int gsl_block_int_fwrite (FILE * stream, const gsl_block_int * b); +-int gsl_block_int_fscanf (FILE * stream, gsl_block_int * b); +-int gsl_block_int_fprintf (FILE * stream, const gsl_block_int * b, const char *format); +- +-int gsl_block_int_raw_fread (FILE * stream, int * b, const size_t n, const size_t stride); +-int gsl_block_int_raw_fwrite (FILE * stream, const int * b, const size_t n, const size_t stride); +-int gsl_block_int_raw_fscanf (FILE * stream, int * b, const size_t n, const size_t stride); +-int gsl_block_int_raw_fprintf (FILE * stream, const int * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_int_size (const gsl_block_int * b); +-int * gsl_block_int_data (const gsl_block_int * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix.h (revision 14079) +@@ -1,25 +0,0 @@ +-#ifndef __GSL_MATRIX_H__ +-#define __GSL_MATRIX_H__ +- +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +- +-#endif /* __GSL_MATRIX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex.h (revision 14079) +@@ -1,136 +0,0 @@ +-/* fft/gsl_fft_complex.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_COMPLEX_H__ +-#define __GSL_FFT_COMPLEX_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Power of 2 routines */ +- +- +-int gsl_fft_complex_radix2_forward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_backward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_inverse (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_transform (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n, +- const gsl_fft_direction sign); +- +-int gsl_fft_complex_radix2_dif_forward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_dif_backward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_dif_inverse (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_radix2_dif_transform (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n, +- const gsl_fft_direction sign); +- +-/* Mixed Radix general-N routines */ +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex *twiddle[64]; +- gsl_complex *trig; +- } +-gsl_fft_complex_wavetable; +- +-typedef struct +-{ +- size_t n; +- double *scratch; +-} +-gsl_fft_complex_workspace; +- +- +-gsl_fft_complex_wavetable *gsl_fft_complex_wavetable_alloc (size_t n); +- +-void gsl_fft_complex_wavetable_free (gsl_fft_complex_wavetable * wavetable); +- +-gsl_fft_complex_workspace *gsl_fft_complex_workspace_alloc (size_t n); +- +-void gsl_fft_complex_workspace_free (gsl_fft_complex_workspace * workspace); +- +-int gsl_fft_complex_memcpy (gsl_fft_complex_wavetable * dest, +- gsl_fft_complex_wavetable * src); +- +- +-int gsl_fft_complex_forward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable * wavetable, +- gsl_fft_complex_workspace * work); +- +-int gsl_fft_complex_backward (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable * wavetable, +- gsl_fft_complex_workspace * work); +- +-int gsl_fft_complex_inverse (gsl_complex_packed_array data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable * wavetable, +- gsl_fft_complex_workspace * work); +- +-int gsl_fft_complex_transform (gsl_complex_packed_array data, +- const size_t stride, const size_t n, +- const gsl_fft_complex_wavetable * wavetable, +- gsl_fft_complex_workspace * work, +- const gsl_fft_direction sign); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_COMPLEX_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_float.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_FLOAT_H__ +-#define __GSL_PERMUTE_FLOAT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_float (const size_t * p, float * data, const size_t stride, const size_t n); +-int gsl_permute_float_inverse (const size_t * p, float * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* ode-initval/gsl_odeiv.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman +- */ +-#ifndef __GSL_ODEIV_H__ +-#define __GSL_ODEIV_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Description of a system of ODEs. +- * +- * y' = f(t,y) = dydt(t, y) +- * +- * The system is specified by giving the right-hand-side +- * of the equation and possibly a jacobian function. +- * +- * Some methods require the jacobian function, which calculates +- * the matrix dfdy and the vector dfdt. The matrix dfdy conforms +- * to the GSL standard, being a continuous range of floating point +- * values, in row-order. +- * +- * As with GSL function objects, user-supplied parameter +- * data is also present. +- */ +- +-typedef struct +-{ +- int (* function) (double t, const double y[], double dydt[], void * params); +- int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params); +- size_t dimension; +- void * params; +-} +-gsl_odeiv_system; +- +-#define GSL_ODEIV_FN_EVAL(S,t,y,f) (*((S)->function))(t,y,f,(S)->params) +-#define GSL_ODEIV_JA_EVAL(S,t,y,dfdy,dfdt) (*((S)->jacobian))(t,y,dfdy,dfdt,(S)->params) +- +- +-/* General stepper object. +- * +- * Opaque object for stepping an ODE system from t to t+h. +- * In general the object has some state which facilitates +- * iterating the stepping operation. +- */ +- +-typedef struct +-{ +- const char * name; +- int can_use_dydt_in; +- int gives_exact_dydt_out; +- void * (*alloc) (size_t dim); +- int (*apply) (void * state, size_t dim, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt); +- int (*reset) (void * state, size_t dim); +- unsigned int (*order) (void * state); +- void (*free) (void * state); +-} +-gsl_odeiv_step_type; +- +-typedef struct { +- const gsl_odeiv_step_type * type; +- size_t dimension; +- void * state; +-} +-gsl_odeiv_step; +- +- +-/* Available stepper types. +- * +- * rk2 : embedded 2nd(3rd) Runge-Kutta +- * rk4 : 4th order (classical) Runge-Kutta +- * rkck : embedded 4th(5th) Runge-Kutta, Cash-Karp +- * rk8pd : embedded 8th(9th) Runge-Kutta, Prince-Dormand +- * rk2imp : implicit 2nd order Runge-Kutta at Gaussian points +- * rk4imp : implicit 4th order Runge-Kutta at Gaussian points +- * gear1 : M=1 implicit Gear method +- * gear2 : M=2 implicit Gear method +- */ +- +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkf45; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkck; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk8pd; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2imp; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2simp; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4imp; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_bsimp; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear1; +-GSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear2; +- +- +-/* Constructor for specialized stepper objects. +- */ +-gsl_odeiv_step * gsl_odeiv_step_alloc(const gsl_odeiv_step_type * T, size_t dim); +-int gsl_odeiv_step_reset(gsl_odeiv_step * s); +-void gsl_odeiv_step_free(gsl_odeiv_step * s); +- +-/* General stepper object methods. +- */ +-const char * gsl_odeiv_step_name(const gsl_odeiv_step * s); +-unsigned int gsl_odeiv_step_order(const gsl_odeiv_step * s); +- +-int gsl_odeiv_step_apply(gsl_odeiv_step * s, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt); +- +-/* General step size control object. +- * +- * The hadjust() method controls the adjustment of +- * step size given the result of a step and the error. +- * Valid hadjust() methods must return one of the codes below. +- * +- * The general data can be used by specializations +- * to store state and control their heuristics. +- */ +- +-typedef struct +-{ +- const char * name; +- void * (*alloc) (void); +- int (*init) (void * state, double eps_abs, double eps_rel, double a_y, double a_dydt); +- int (*hadjust) (void * state, size_t dim, unsigned int ord, const double y[], const double yerr[], const double yp[], double * h); +- void (*free) (void * state); +-} +-gsl_odeiv_control_type; +- +-typedef struct +-{ +- const gsl_odeiv_control_type * type; +- void * state; +-} +-gsl_odeiv_control; +- +-/* Possible return values for an hadjust() evolution method. +- */ +-#define GSL_ODEIV_HADJ_INC 1 /* step was increased */ +-#define GSL_ODEIV_HADJ_NIL 0 /* step unchanged */ +-#define GSL_ODEIV_HADJ_DEC (-1) /* step decreased */ +- +-gsl_odeiv_control * gsl_odeiv_control_alloc(const gsl_odeiv_control_type * T); +-int gsl_odeiv_control_init(gsl_odeiv_control * c, double eps_abs, double eps_rel, double a_y, double a_dydt); +-void gsl_odeiv_control_free(gsl_odeiv_control * c); +-int gsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, const double y[], const double yerr[], const double dydt[], double * h); +-const char * gsl_odeiv_control_name(const gsl_odeiv_control * c); +- +-/* Available control object constructors. +- * +- * The standard control object is a four parameter heuristic +- * defined as follows: +- * D0 = eps_abs + eps_rel * (a_y |y| + a_dydt h |y'|) +- * D1 = |yerr| +- * q = consistency order of method (q=4 for 4(5) embedded RK) +- * S = safety factor (0.9 say) +- * +- * / (D0/D1)^(1/(q+1)) D0 >= D1 +- * h_NEW = S h_OLD * | +- * \ (D0/D1)^(1/q) D0 < D1 +- * +- * This encompasses all the standard error scaling methods. +- * +- * The y method is the standard method with a_y=1, a_dydt=0. +- * The yp method is the standard method with a_y=0, a_dydt=1. +- */ +- +-gsl_odeiv_control * gsl_odeiv_control_standard_new(double eps_abs, double eps_rel, double a_y, double a_dydt); +-gsl_odeiv_control * gsl_odeiv_control_y_new(double eps_abs, double eps_rel); +-gsl_odeiv_control * gsl_odeiv_control_yp_new(double eps_abs, double eps_rel); +- +-/* This controller computes errors using different absolute errors for +- * each component +- * +- * D0 = eps_abs * scale_abs[i] + eps_rel * (a_y |y| + a_dydt h |y'|) +- */ +-gsl_odeiv_control * gsl_odeiv_control_scaled_new(double eps_abs, double eps_rel, double a_y, double a_dydt, const double scale_abs[], size_t dim); +- +-/* General evolution object. +- */ +-typedef struct { +- size_t dimension; +- double * y0; +- double * yerr; +- double * dydt_in; +- double * dydt_out; +- double last_step; +- unsigned long int count; +- unsigned long int failed_steps; +-} +-gsl_odeiv_evolve; +- +-/* Evolution object methods. +- */ +-gsl_odeiv_evolve * gsl_odeiv_evolve_alloc(size_t dim); +-int gsl_odeiv_evolve_apply(gsl_odeiv_evolve * e, gsl_odeiv_control * con, gsl_odeiv_step * step, const gsl_odeiv_system * dydt, double * t, double t1, double * h, double y[]); +-int gsl_odeiv_evolve_reset(gsl_odeiv_evolve * e); +-void gsl_odeiv_evolve_free(gsl_odeiv_evolve * e); +- +- +-__END_DECLS +- +-#endif /* __GSL_ODEIV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_result.h (revision 14079) +@@ -1,59 +0,0 @@ +-/* specfunc/gsl_sf_result.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_RESULT_H__ +-#define __GSL_SF_RESULT_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_sf_result_struct { +- double val; +- double err; +-}; +-typedef struct gsl_sf_result_struct gsl_sf_result; +- +-#define GSL_SF_RESULT_SET(r,v,e) do { (r)->val=(v); (r)->err=(e); } while(0) +- +- +-struct gsl_sf_result_e10_struct { +- double val; +- double err; +- int e10; +-}; +-typedef struct gsl_sf_result_e10_struct gsl_sf_result_e10; +- +- +-int gsl_sf_result_smash_e(const gsl_sf_result_e10 * re, gsl_sf_result * r); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_RESULT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_short.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_SHORT_H__ +-#define __GSL_SORT_SHORT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_short (short * data, const size_t stride, const size_t n); +-void gsl_sort_short_index (size_t * p, const short * data, const size_t stride, const size_t n); +- +-int gsl_sort_short_smallest (short * dest, const size_t k, const short * src, const size_t stride, const size_t n); +-int gsl_sort_short_smallest_index (size_t * p, const size_t k, const short * src, const size_t stride, const size_t n); +- +-int gsl_sort_short_largest (short * dest, const size_t k, const short * src, const size_t stride, const size_t n); +-int gsl_sort_short_largest_index (size_t * p, const size_t k, const short * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real_float.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* fft/gsl_fft_real_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_REAL_FLOAT_H__ +-#define __GSL_FFT_REAL_FLOAT_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_fft_real_float_radix2_transform (float data[], const size_t stride, const size_t n) ; +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex_float *twiddle[64]; +- gsl_complex_float *trig; +- } +-gsl_fft_real_wavetable_float; +- +-typedef struct +- { +- size_t n; +- float *scratch; +- } +-gsl_fft_real_workspace_float; +- +-gsl_fft_real_wavetable_float * gsl_fft_real_wavetable_float_alloc (size_t n); +- +-void gsl_fft_real_wavetable_float_free (gsl_fft_real_wavetable_float * wavetable); +- +-gsl_fft_real_workspace_float * gsl_fft_real_workspace_float_alloc (size_t n); +- +-void gsl_fft_real_workspace_float_free (gsl_fft_real_workspace_float * workspace); +- +-int gsl_fft_real_float_transform (float data[], const size_t stride, const size_t n, +- const gsl_fft_real_wavetable_float * wavetable, +- gsl_fft_real_workspace_float * work); +- +- +-int gsl_fft_real_float_unpack (const float real_float_coefficient[], +- float complex_coefficient[], +- const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_REAL_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_uint.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_UINT_H__ +-#define __GSL_SORT_VECTOR_UINT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_uint (gsl_vector_uint * v); +-int gsl_sort_vector_uint_index (gsl_permutation * p, const gsl_vector_uint * v); +- +-int gsl_sort_vector_uint_smallest (unsigned int * dest, const size_t k, const gsl_vector_uint * v); +-int gsl_sort_vector_uint_largest (unsigned int * dest, const size_t k, const gsl_vector_uint * v); +- +-int gsl_sort_vector_uint_smallest_index (size_t * p, const size_t k, const gsl_vector_uint * v); +-int gsl_sort_vector_uint_largest_index (size_t * p, const size_t k, const gsl_vector_uint * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit_nlin.h (revision 14079) +@@ -1,172 +0,0 @@ +-/* multifit_nlin/gsl_multifit_nlin.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MULTIFIT_NLIN_H__ +-#define __GSL_MULTIFIT_NLIN_H__ +- +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_multifit_gradient (const gsl_matrix * J, const gsl_vector * f, +- gsl_vector * g); +- +-int gsl_multifit_covar (const gsl_matrix * J, double epsrel, gsl_matrix * covar); +- +- +-/* Definition of vector-valued functions with parameters based on gsl_vector */ +- +-struct gsl_multifit_function_struct +-{ +- int (* f) (const gsl_vector * x, void * params, gsl_vector * f); +- size_t n; /* number of functions */ +- size_t p; /* number of independent variables */ +- void * params; +-}; +- +-typedef struct gsl_multifit_function_struct gsl_multifit_function ; +- +-#define GSL_MULTIFIT_FN_EVAL(F,x,y) (*((F)->f))(x,(F)->params,(y)) +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n, size_t p); +- int (*set) (void *state, gsl_multifit_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); +- int (*iterate) (void *state, gsl_multifit_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); +- void (*free) (void *state); +- } +-gsl_multifit_fsolver_type; +- +-typedef struct +- { +- const gsl_multifit_fsolver_type * type; +- gsl_multifit_function * function ; +- gsl_vector * x ; +- gsl_vector * f ; +- gsl_vector * dx ; +- void *state; +- } +-gsl_multifit_fsolver; +- +-gsl_multifit_fsolver * +-gsl_multifit_fsolver_alloc (const gsl_multifit_fsolver_type * T, +- size_t n, size_t p); +- +-void gsl_multifit_fsolver_free (gsl_multifit_fsolver * s); +- +-int gsl_multifit_fsolver_set (gsl_multifit_fsolver * s, +- gsl_multifit_function * f, +- const gsl_vector * x); +- +-int gsl_multifit_fsolver_iterate (gsl_multifit_fsolver * s); +- +-const char * gsl_multifit_fsolver_name (const gsl_multifit_fsolver * s); +-gsl_vector * gsl_multifit_fsolver_position (const gsl_multifit_fsolver * s); +- +-/* Definition of vector-valued functions and gradient with parameters +- based on gsl_vector */ +- +-struct gsl_multifit_function_fdf_struct +-{ +- int (* f) (const gsl_vector * x, void * params, gsl_vector * f); +- int (* df) (const gsl_vector * x, void * params, gsl_matrix * df); +- int (* fdf) (const gsl_vector * x, void * params, gsl_vector * f, gsl_matrix *df); +- size_t n; /* number of functions */ +- size_t p; /* number of independent variables */ +- void * params; +-}; +- +-typedef struct gsl_multifit_function_fdf_struct gsl_multifit_function_fdf ; +- +-#define GSL_MULTIFIT_FN_EVAL_F(F,x,y) ((*((F)->f))(x,(F)->params,(y))) +-#define GSL_MULTIFIT_FN_EVAL_DF(F,x,dy) ((*((F)->df))(x,(F)->params,(dy))) +-#define GSL_MULTIFIT_FN_EVAL_F_DF(F,x,y,dy) ((*((F)->fdf))(x,(F)->params,(y),(dy))) +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n, size_t p); +- int (*set) (void *state, gsl_multifit_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); +- int (*iterate) (void *state, gsl_multifit_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); +- void (*free) (void *state); +- } +-gsl_multifit_fdfsolver_type; +- +-typedef struct +- { +- const gsl_multifit_fdfsolver_type * type; +- gsl_multifit_function_fdf * fdf ; +- gsl_vector * x; +- gsl_vector * f; +- gsl_matrix * J; +- gsl_vector * dx; +- void *state; +- } +-gsl_multifit_fdfsolver; +- +- +-gsl_multifit_fdfsolver * +-gsl_multifit_fdfsolver_alloc (const gsl_multifit_fdfsolver_type * T, +- size_t n, size_t p); +- +-int +-gsl_multifit_fdfsolver_set (gsl_multifit_fdfsolver * s, +- gsl_multifit_function_fdf * fdf, +- const gsl_vector * x); +- +-int +-gsl_multifit_fdfsolver_iterate (gsl_multifit_fdfsolver * s); +- +-void +-gsl_multifit_fdfsolver_free (gsl_multifit_fdfsolver * s); +- +-const char * gsl_multifit_fdfsolver_name (const gsl_multifit_fdfsolver * s); +-gsl_vector * gsl_multifit_fdfsolver_position (const gsl_multifit_fdfsolver * s); +- +-int gsl_multifit_test_delta (const gsl_vector * dx, const gsl_vector * x, +- double epsabs, double epsrel); +- +-int gsl_multifit_test_gradient (const gsl_vector * g, double epsabs); +- +-/* extern const gsl_multifit_fsolver_type * gsl_multifit_fsolver_gradient; */ +- +-GSL_VAR const gsl_multifit_fdfsolver_type * gsl_multifit_fdfsolver_lmder; +-GSL_VAR const gsl_multifit_fdfsolver_type * gsl_multifit_fdfsolver_lmsder; +- +- +-__END_DECLS +- +-#endif /* __GSL_MULTIFIT_NLIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ulong.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_ULONG_H__ +-#define __GSL_SORT_VECTOR_ULONG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_ulong (gsl_vector_ulong * v); +-int gsl_sort_vector_ulong_index (gsl_permutation * p, const gsl_vector_ulong * v); +- +-int gsl_sort_vector_ulong_smallest (unsigned long * dest, const size_t k, const gsl_vector_ulong * v); +-int gsl_sort_vector_ulong_largest (unsigned long * dest, const size_t k, const gsl_vector_ulong * v); +- +-int gsl_sort_vector_ulong_smallest_index (size_t * p, const size_t k, const gsl_vector_ulong * v); +-int gsl_sort_vector_ulong_largest_index (size_t * p, const size_t k, const gsl_vector_ulong * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_test.h (revision 14079) +@@ -1,66 +0,0 @@ +-/* err/gsl_test.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_TEST_H__ +-#define __GSL_TEST_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void +- gsl_test (int status, const char *test_description, ...); +- +-void +-gsl_test_rel (double result, double expected, double relative_error, +- const char *test_description, ...) ; +- +-void +-gsl_test_abs (double result, double expected, double absolute_error, +- const char *test_description, ...) ; +- +-void +-gsl_test_factor (double result, double expected, double factor, +- const char *test_description, ...) ; +- +-void +-gsl_test_int (int result, int expected, const char *test_description, ...) ; +- +-void +-gsl_test_str (const char * result, const char * expected, +- const char *test_description, ...) ; +- +-void +- gsl_test_verbose (int verbose) ; +- +-int +- gsl_test_summary (void) ; +- +- +-__END_DECLS +- +-#endif /* __GSL_TEST_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft.h (revision 14079) +@@ -1,60 +0,0 @@ +-/* fft/gsl_fft.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_H__ +-#define __GSL_FFT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-#ifndef GSL_DISABLE_DEPRECATED +-typedef enum +- { +- forward = -1, backward = +1, +- gsl_fft_forward = -1, gsl_fft_backward = +1 +- } +-gsl_fft_direction; +-#else +-typedef enum +- { +- gsl_fft_forward = -1, gsl_fft_backward = +1 +- } +-gsl_fft_direction; +-#endif +- +-/* this gives the sign in the formula +- +- h(f) = \sum x(t) exp(+/- 2 pi i f t) +- +- where - is the forward transform direction and + the inverse direction */ +- +-__END_DECLS +- +-#endif /* __GSL_FFT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_histogram2d.h (revision 14079) +@@ -1,172 +0,0 @@ +-/* histogram/gsl_histogram2d.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_HISTOGRAM2D_H__ +-#define __GSL_HISTOGRAM2D_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- size_t nx, ny ; +- double * xrange ; +- double * yrange ; +- double * bin ; +-} gsl_histogram2d ; +- +-typedef struct { +- size_t nx, ny ; +- double * xrange ; +- double * yrange ; +- double * sum ; +-} gsl_histogram2d_pdf ; +- +-gsl_histogram2d * gsl_histogram2d_alloc (const size_t nx, const size_t ny); +-gsl_histogram2d * gsl_histogram2d_calloc (const size_t nx, const size_t ny); +-gsl_histogram2d * gsl_histogram2d_calloc_uniform (const size_t nx, const size_t ny, +- const double xmin, const double xmax, +- const double ymin, const double ymax); +- +-void gsl_histogram2d_free (gsl_histogram2d * h); +- +-int gsl_histogram2d_increment (gsl_histogram2d * h, double x, double y); +-int gsl_histogram2d_accumulate (gsl_histogram2d * h, +- double x, double y, double weight); +-int gsl_histogram2d_find (const gsl_histogram2d * h, +- const double x, const double y, size_t * i, size_t * j); +- +-double gsl_histogram2d_get (const gsl_histogram2d * h, const size_t i, const size_t j); +-int gsl_histogram2d_get_xrange (const gsl_histogram2d * h, const size_t i, +- double * xlower, double * xupper); +-int gsl_histogram2d_get_yrange (const gsl_histogram2d * h, const size_t j, +- double * ylower, double * yupper); +- +- +-double gsl_histogram2d_xmax (const gsl_histogram2d * h); +-double gsl_histogram2d_xmin (const gsl_histogram2d * h); +-size_t gsl_histogram2d_nx (const gsl_histogram2d * h); +- +-double gsl_histogram2d_ymax (const gsl_histogram2d * h); +-double gsl_histogram2d_ymin (const gsl_histogram2d * h); +-size_t gsl_histogram2d_ny (const gsl_histogram2d * h); +- +-void gsl_histogram2d_reset (gsl_histogram2d * h); +- +-gsl_histogram2d * +-gsl_histogram2d_calloc_range(size_t nx, size_t ny, +- double *xrange, double *yrange); +- +-int +-gsl_histogram2d_set_ranges_uniform (gsl_histogram2d * h, +- double xmin, double xmax, +- double ymin, double ymax); +- +-int +-gsl_histogram2d_set_ranges (gsl_histogram2d * h, +- const double xrange[], size_t xsize, +- const double yrange[], size_t ysize); +- +-int +-gsl_histogram2d_memcpy(gsl_histogram2d *dest, const gsl_histogram2d *source); +- +-gsl_histogram2d * +-gsl_histogram2d_clone(const gsl_histogram2d * source); +- +-double +-gsl_histogram2d_max_val(const gsl_histogram2d *h); +- +-void +-gsl_histogram2d_max_bin (const gsl_histogram2d *h, size_t *i, size_t *j); +- +-double +-gsl_histogram2d_min_val(const gsl_histogram2d *h); +- +-void +-gsl_histogram2d_min_bin (const gsl_histogram2d *h, size_t *i, size_t *j); +- +-double +-gsl_histogram2d_xmean (const gsl_histogram2d * h); +- +-double +-gsl_histogram2d_ymean (const gsl_histogram2d * h); +- +-double +-gsl_histogram2d_xsigma (const gsl_histogram2d * h); +- +-double +-gsl_histogram2d_ysigma (const gsl_histogram2d * h); +- +-double +-gsl_histogram2d_cov (const gsl_histogram2d * h); +- +-double +-gsl_histogram2d_sum (const gsl_histogram2d *h); +- +-int +-gsl_histogram2d_equal_bins_p(const gsl_histogram2d *h1, +- const gsl_histogram2d *h2) ; +- +-int +-gsl_histogram2d_add(gsl_histogram2d *h1, const gsl_histogram2d *h2); +- +-int +-gsl_histogram2d_sub(gsl_histogram2d *h1, const gsl_histogram2d *h2); +- +-int +-gsl_histogram2d_mul(gsl_histogram2d *h1, const gsl_histogram2d *h2); +- +-int +-gsl_histogram2d_div(gsl_histogram2d *h1, const gsl_histogram2d *h2); +- +-int +-gsl_histogram2d_scale(gsl_histogram2d *h, double scale); +- +-int +-gsl_histogram2d_shift(gsl_histogram2d *h, double shift); +- +-int gsl_histogram2d_fwrite (FILE * stream, const gsl_histogram2d * h) ; +-int gsl_histogram2d_fread (FILE * stream, gsl_histogram2d * h); +-int gsl_histogram2d_fprintf (FILE * stream, const gsl_histogram2d * h, +- const char * range_format, +- const char * bin_format); +-int gsl_histogram2d_fscanf (FILE * stream, gsl_histogram2d * h); +- +-gsl_histogram2d_pdf * gsl_histogram2d_pdf_alloc (const size_t nx, const size_t ny); +-int gsl_histogram2d_pdf_init (gsl_histogram2d_pdf * p, const gsl_histogram2d * h); +-void gsl_histogram2d_pdf_free (gsl_histogram2d_pdf * p); +-int gsl_histogram2d_pdf_sample (const gsl_histogram2d_pdf * p, +- double r1, double r2, +- double * x, double * y); +- +-__END_DECLS +- +-#endif /* __GSL_HISTOGRAM2D_H__ */ +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uchar.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_UCHAR_H__ +-#define __GSL_VECTOR_UCHAR_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- unsigned char *data; +- gsl_block_uchar *block; +- int owner; +-} +-gsl_vector_uchar; +- +-typedef struct +-{ +- gsl_vector_uchar vector; +-} _gsl_vector_uchar_view; +- +-typedef _gsl_vector_uchar_view gsl_vector_uchar_view; +- +-typedef struct +-{ +- gsl_vector_uchar vector; +-} _gsl_vector_uchar_const_view; +- +-typedef const _gsl_vector_uchar_const_view gsl_vector_uchar_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_uchar *gsl_vector_uchar_alloc (const size_t n); +-gsl_vector_uchar *gsl_vector_uchar_calloc (const size_t n); +- +-gsl_vector_uchar *gsl_vector_uchar_alloc_from_block (gsl_block_uchar * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_uchar *gsl_vector_uchar_alloc_from_vector (gsl_vector_uchar * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_uchar_free (gsl_vector_uchar * v); +- +-/* Views */ +- +-_gsl_vector_uchar_view +-gsl_vector_uchar_view_array (unsigned char *v, size_t n); +- +-_gsl_vector_uchar_view +-gsl_vector_uchar_view_array_with_stride (unsigned char *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_uchar_const_view +-gsl_vector_uchar_const_view_array (const unsigned char *v, size_t n); +- +-_gsl_vector_uchar_const_view +-gsl_vector_uchar_const_view_array_with_stride (const unsigned char *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_uchar_view +-gsl_vector_uchar_subvector (gsl_vector_uchar *v, +- size_t i, +- size_t n); +- +-_gsl_vector_uchar_view +-gsl_vector_uchar_subvector_with_stride (gsl_vector_uchar *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_uchar_const_view +-gsl_vector_uchar_const_subvector (const gsl_vector_uchar *v, +- size_t i, +- size_t n); +- +-_gsl_vector_uchar_const_view +-gsl_vector_uchar_const_subvector_with_stride (const gsl_vector_uchar *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_uchar_set_zero (gsl_vector_uchar * v); +-void gsl_vector_uchar_set_all (gsl_vector_uchar * v, unsigned char x); +-int gsl_vector_uchar_set_basis (gsl_vector_uchar * v, size_t i); +- +-int gsl_vector_uchar_fread (FILE * stream, gsl_vector_uchar * v); +-int gsl_vector_uchar_fwrite (FILE * stream, const gsl_vector_uchar * v); +-int gsl_vector_uchar_fscanf (FILE * stream, gsl_vector_uchar * v); +-int gsl_vector_uchar_fprintf (FILE * stream, const gsl_vector_uchar * v, +- const char *format); +- +-int gsl_vector_uchar_memcpy (gsl_vector_uchar * dest, const gsl_vector_uchar * src); +- +-int gsl_vector_uchar_reverse (gsl_vector_uchar * v); +- +-int gsl_vector_uchar_swap (gsl_vector_uchar * v, gsl_vector_uchar * w); +-int gsl_vector_uchar_swap_elements (gsl_vector_uchar * v, const size_t i, const size_t j); +- +-unsigned char gsl_vector_uchar_max (const gsl_vector_uchar * v); +-unsigned char gsl_vector_uchar_min (const gsl_vector_uchar * v); +-void gsl_vector_uchar_minmax (const gsl_vector_uchar * v, unsigned char * min_out, unsigned char * max_out); +- +-size_t gsl_vector_uchar_max_index (const gsl_vector_uchar * v); +-size_t gsl_vector_uchar_min_index (const gsl_vector_uchar * v); +-void gsl_vector_uchar_minmax_index (const gsl_vector_uchar * v, size_t * imin, size_t * imax); +- +-int gsl_vector_uchar_add (gsl_vector_uchar * a, const gsl_vector_uchar * b); +-int gsl_vector_uchar_sub (gsl_vector_uchar * a, const gsl_vector_uchar * b); +-int gsl_vector_uchar_mul (gsl_vector_uchar * a, const gsl_vector_uchar * b); +-int gsl_vector_uchar_div (gsl_vector_uchar * a, const gsl_vector_uchar * b); +-int gsl_vector_uchar_scale (gsl_vector_uchar * a, const double x); +-int gsl_vector_uchar_add_constant (gsl_vector_uchar * a, const double x); +- +-int gsl_vector_uchar_equal (const gsl_vector_uchar * u, +- const gsl_vector_uchar * v); +- +-int gsl_vector_uchar_isnull (const gsl_vector_uchar * v); +-int gsl_vector_uchar_ispos (const gsl_vector_uchar * v); +-int gsl_vector_uchar_isneg (const gsl_vector_uchar * v); +-int gsl_vector_uchar_isnonneg (const gsl_vector_uchar * v); +- +-INLINE_DECL unsigned char gsl_vector_uchar_get (const gsl_vector_uchar * v, const size_t i); +-INLINE_DECL void gsl_vector_uchar_set (gsl_vector_uchar * v, const size_t i, unsigned char x); +-INLINE_DECL unsigned char * gsl_vector_uchar_ptr (gsl_vector_uchar * v, const size_t i); +-INLINE_DECL const unsigned char * gsl_vector_uchar_const_ptr (const gsl_vector_uchar * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-unsigned char +-gsl_vector_uchar_get (const gsl_vector_uchar * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_uchar_set (gsl_vector_uchar * v, const size_t i, unsigned char x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-unsigned char * +-gsl_vector_uchar_ptr (gsl_vector_uchar * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (unsigned char *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const unsigned char * +-gsl_vector_uchar_const_ptr (const gsl_vector_uchar * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const unsigned char *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_UCHAR_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_mathieu.h (revision 14079) +@@ -1,107 +0,0 @@ +-/* specfunc/gsl_sf_mathieu.h +- * +- * Copyright (C) 2002 Lowell Johnson +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +- */ +- +-/* Author: L. Johnson */ +- +-#ifndef __GSL_SF_MATHIEU_H__ +-#define __GSL_SF_MATHIEU_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-#define GSL_SF_MATHIEU_COEFF 100 +- +-typedef struct +-{ +- size_t size; +- size_t even_order; +- size_t odd_order; +- int extra_values; +- double qa; /* allow for caching of results: not implemented yet */ +- double qb; /* allow for caching of results: not implemented yet */ +- double *aa; +- double *bb; +- double *dd; +- double *ee; +- double *tt; +- double *e2; +- double *zz; +- gsl_vector *eval; +- gsl_matrix *evec; +- gsl_eigen_symmv_workspace *wmat; +-} gsl_sf_mathieu_workspace; +- +- +-/* Compute an array of characteristic (eigen) values from the recurrence +- matrices for the Mathieu equations. */ +-int gsl_sf_mathieu_a_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]); +-int gsl_sf_mathieu_b_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]); +- +-/* Compute the characteristic value for a Mathieu function of order n and +- type ntype. */ +-int gsl_sf_mathieu_a(int order, double qq, gsl_sf_result *result); +-int gsl_sf_mathieu_b(int order, double qq, gsl_sf_result *result); +- +-/* Compute the Fourier coefficients for a Mathieu function. */ +-int gsl_sf_mathieu_a_coeff(int order, double qq, double aa, double coeff[]); +-int gsl_sf_mathieu_b_coeff(int order, double qq, double aa, double coeff[]); +- +-/* Allocate computational storage space for eigenvalue solution. */ +-gsl_sf_mathieu_workspace *gsl_sf_mathieu_alloc(const size_t nn, +- const double qq); +-void gsl_sf_mathieu_free(gsl_sf_mathieu_workspace *workspace); +- +-/* Compute an angular Mathieu function. */ +-int gsl_sf_mathieu_ce(int order, double qq, double zz, gsl_sf_result *result); +-int gsl_sf_mathieu_se(int order, double qq, double zz, gsl_sf_result *result); +-int gsl_sf_mathieu_ce_array(int nmin, int nmax, double qq, double zz, +- gsl_sf_mathieu_workspace *work, +- double result_array[]); +-int gsl_sf_mathieu_se_array(int nmin, int nmax, double qq, double zz, +- gsl_sf_mathieu_workspace *work, +- double result_array[]); +- +-/* Compute a radial Mathieu function. */ +-int gsl_sf_mathieu_Mc(int kind, int order, double qq, double zz, +- gsl_sf_result *result); +-int gsl_sf_mathieu_Ms(int kind, int order, double qq, double zz, +- gsl_sf_result *result); +-int gsl_sf_mathieu_Mc_array(int kind, int nmin, int nmax, double qq, +- double zz, gsl_sf_mathieu_workspace *work, +- double result_array[]); +-int gsl_sf_mathieu_Ms_array(int kind, int nmin, int nmax, double qq, +- double zz, gsl_sf_mathieu_workspace *work, +- double result_array[]); +- +- +-__END_DECLS +- +-#endif /* !__GSL_SF_MATHIEU_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_heapsort.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* sort/gsl_heapsort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_HEAPSORT_H__ +-#define __GSL_HEAPSORT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef int (*gsl_comparison_fn_t) (const void *, const void *); +- +-void gsl_heapsort (void * array, size_t count, size_t size, gsl_comparison_fn_t compare); +-int gsl_heapsort_index (size_t * p, const void * array, size_t count, size_t size, gsl_comparison_fn_t compare); +- +-__END_DECLS +- +-#endif /* __GSL_HEAPSORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort.h (revision 14079) +@@ -1,20 +0,0 @@ +-#ifndef __GSL_SORT_H__ +-#define __GSL_SORT_H__ +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_SORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_eigen.h (revision 14079) +@@ -1,347 +0,0 @@ +-/* eigen/gsl_eigen.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2006, 2007 Gerard Jungman, Brian Gough, Patrick Alken +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_EIGEN_H__ +-#define __GSL_EIGEN_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- size_t size; +- double * d; +- double * sd; +-} gsl_eigen_symm_workspace; +- +-gsl_eigen_symm_workspace * gsl_eigen_symm_alloc (const size_t n); +-void gsl_eigen_symm_free (gsl_eigen_symm_workspace * w); +-int gsl_eigen_symm (gsl_matrix * A, gsl_vector * eval, gsl_eigen_symm_workspace * w); +- +-typedef struct { +- size_t size; +- double * d; +- double * sd; +- double * gc; +- double * gs; +-} gsl_eigen_symmv_workspace; +- +-gsl_eigen_symmv_workspace * gsl_eigen_symmv_alloc (const size_t n); +-void gsl_eigen_symmv_free (gsl_eigen_symmv_workspace * w); +-int gsl_eigen_symmv (gsl_matrix * A, gsl_vector * eval, gsl_matrix * evec, gsl_eigen_symmv_workspace * w); +- +-typedef struct { +- size_t size; +- double * d; +- double * sd; +- double * tau; +-} gsl_eigen_herm_workspace; +- +-gsl_eigen_herm_workspace * gsl_eigen_herm_alloc (const size_t n); +-void gsl_eigen_herm_free (gsl_eigen_herm_workspace * w); +-int gsl_eigen_herm (gsl_matrix_complex * A, gsl_vector * eval, +- gsl_eigen_herm_workspace * w); +- +-typedef struct { +- size_t size; +- double * d; +- double * sd; +- double * tau; +- double * gc; +- double * gs; +-} gsl_eigen_hermv_workspace; +- +-gsl_eigen_hermv_workspace * gsl_eigen_hermv_alloc (const size_t n); +-void gsl_eigen_hermv_free (gsl_eigen_hermv_workspace * w); +-int gsl_eigen_hermv (gsl_matrix_complex * A, gsl_vector * eval, +- gsl_matrix_complex * evec, +- gsl_eigen_hermv_workspace * w); +- +-typedef struct { +- size_t size; /* matrix size */ +- size_t max_iterations; /* max iterations since last eigenvalue found */ +- size_t n_iter; /* number of iterations since last eigenvalue found */ +- size_t n_evals; /* number of eigenvalues found so far */ +- +- int compute_t; /* compute Schur form T = Z^t A Z */ +- +- gsl_matrix *H; /* pointer to Hessenberg matrix */ +- gsl_matrix *Z; /* pointer to Schur vector matrix */ +-} gsl_eigen_francis_workspace; +- +-gsl_eigen_francis_workspace * gsl_eigen_francis_alloc (void); +-void gsl_eigen_francis_free (gsl_eigen_francis_workspace * w); +-void gsl_eigen_francis_T (const int compute_t, +- gsl_eigen_francis_workspace * w); +-int gsl_eigen_francis (gsl_matrix * H, gsl_vector_complex * eval, +- gsl_eigen_francis_workspace * w); +-int gsl_eigen_francis_Z (gsl_matrix * H, gsl_vector_complex * eval, +- gsl_matrix * Z, +- gsl_eigen_francis_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_vector *diag; /* diagonal matrix elements from balancing */ +- gsl_vector *tau; /* Householder coefficients */ +- gsl_matrix *Z; /* pointer to Z matrix */ +- int do_balance; /* perform balancing transformation? */ +- size_t n_evals; /* number of eigenvalues found */ +- +- gsl_eigen_francis_workspace *francis_workspace_p; +-} gsl_eigen_nonsymm_workspace; +- +-gsl_eigen_nonsymm_workspace * gsl_eigen_nonsymm_alloc (const size_t n); +-void gsl_eigen_nonsymm_free (gsl_eigen_nonsymm_workspace * w); +-void gsl_eigen_nonsymm_params (const int compute_t, const int balance, +- gsl_eigen_nonsymm_workspace *w); +-int gsl_eigen_nonsymm (gsl_matrix * A, gsl_vector_complex * eval, +- gsl_eigen_nonsymm_workspace * w); +-int gsl_eigen_nonsymm_Z (gsl_matrix * A, gsl_vector_complex * eval, +- gsl_matrix * Z, gsl_eigen_nonsymm_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_vector *work; /* scratch workspace */ +- gsl_vector *work2; /* scratch workspace */ +- gsl_vector *work3; /* scratch workspace */ +- +- gsl_matrix *Z; /* pointer to Schur vectors */ +- +- gsl_eigen_nonsymm_workspace *nonsymm_workspace_p; +-} gsl_eigen_nonsymmv_workspace; +- +-gsl_eigen_nonsymmv_workspace * gsl_eigen_nonsymmv_alloc (const size_t n); +-void gsl_eigen_nonsymmv_free (gsl_eigen_nonsymmv_workspace * w); +-void gsl_eigen_nonsymmv_params (const int balance, +- gsl_eigen_nonsymmv_workspace *w); +-int gsl_eigen_nonsymmv (gsl_matrix * A, gsl_vector_complex * eval, +- gsl_matrix_complex * evec, +- gsl_eigen_nonsymmv_workspace * w); +-int gsl_eigen_nonsymmv_Z (gsl_matrix * A, gsl_vector_complex * eval, +- gsl_matrix_complex * evec, gsl_matrix * Z, +- gsl_eigen_nonsymmv_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_eigen_symm_workspace *symm_workspace_p; +-} gsl_eigen_gensymm_workspace; +- +-gsl_eigen_gensymm_workspace * gsl_eigen_gensymm_alloc (const size_t n); +-void gsl_eigen_gensymm_free (gsl_eigen_gensymm_workspace * w); +-int gsl_eigen_gensymm (gsl_matrix * A, gsl_matrix * B, +- gsl_vector * eval, gsl_eigen_gensymm_workspace * w); +-int gsl_eigen_gensymm_standardize (gsl_matrix * A, const gsl_matrix * B); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_eigen_symmv_workspace *symmv_workspace_p; +-} gsl_eigen_gensymmv_workspace; +- +-gsl_eigen_gensymmv_workspace * gsl_eigen_gensymmv_alloc (const size_t n); +-void gsl_eigen_gensymmv_free (gsl_eigen_gensymmv_workspace * w); +-int gsl_eigen_gensymmv (gsl_matrix * A, gsl_matrix * B, +- gsl_vector * eval, gsl_matrix * evec, +- gsl_eigen_gensymmv_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_eigen_herm_workspace *herm_workspace_p; +-} gsl_eigen_genherm_workspace; +- +-gsl_eigen_genherm_workspace * gsl_eigen_genherm_alloc (const size_t n); +-void gsl_eigen_genherm_free (gsl_eigen_genherm_workspace * w); +-int gsl_eigen_genherm (gsl_matrix_complex * A, gsl_matrix_complex * B, +- gsl_vector * eval, gsl_eigen_genherm_workspace * w); +-int gsl_eigen_genherm_standardize (gsl_matrix_complex * A, +- const gsl_matrix_complex * B); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_eigen_hermv_workspace *hermv_workspace_p; +-} gsl_eigen_genhermv_workspace; +- +-gsl_eigen_genhermv_workspace * gsl_eigen_genhermv_alloc (const size_t n); +-void gsl_eigen_genhermv_free (gsl_eigen_genhermv_workspace * w); +-int gsl_eigen_genhermv (gsl_matrix_complex * A, gsl_matrix_complex * B, +- gsl_vector * eval, gsl_matrix_complex * evec, +- gsl_eigen_genhermv_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- gsl_vector *work; /* scratch workspace */ +- +- size_t n_evals; /* number of eigenvalues found */ +- size_t max_iterations; /* maximum QZ iterations allowed */ +- size_t n_iter; /* number of iterations since last eigenvalue found */ +- double eshift; /* exceptional shift counter */ +- +- int needtop; /* need to compute top index? */ +- +- double atol; /* tolerance for splitting A matrix */ +- double btol; /* tolerance for splitting B matrix */ +- +- double ascale; /* scaling factor for shifts */ +- double bscale; /* scaling factor for shifts */ +- +- gsl_matrix *H; /* pointer to hessenberg matrix */ +- gsl_matrix *R; /* pointer to upper triangular matrix */ +- +- int compute_s; /* compute generalized Schur form S */ +- int compute_t; /* compute generalized Schur form T */ +- +- gsl_matrix *Q; /* pointer to left Schur vectors */ +- gsl_matrix *Z; /* pointer to right Schur vectors */ +-} gsl_eigen_gen_workspace; +- +-gsl_eigen_gen_workspace * gsl_eigen_gen_alloc (const size_t n); +-void gsl_eigen_gen_free (gsl_eigen_gen_workspace * w); +-void gsl_eigen_gen_params (const int compute_s, const int compute_t, +- const int balance, gsl_eigen_gen_workspace * w); +-int gsl_eigen_gen (gsl_matrix * A, gsl_matrix * B, +- gsl_vector_complex * alpha, gsl_vector * beta, +- gsl_eigen_gen_workspace * w); +-int gsl_eigen_gen_QZ (gsl_matrix * A, gsl_matrix * B, +- gsl_vector_complex * alpha, gsl_vector * beta, +- gsl_matrix * Q, gsl_matrix * Z, +- gsl_eigen_gen_workspace * w); +- +-typedef struct { +- size_t size; /* size of matrices */ +- +- gsl_vector *work1; /* 1-norm of columns of A */ +- gsl_vector *work2; /* 1-norm of columns of B */ +- gsl_vector *work3; /* real part of eigenvector */ +- gsl_vector *work4; /* imag part of eigenvector */ +- gsl_vector *work5; /* real part of back-transformed eigenvector */ +- gsl_vector *work6; /* imag part of back-transformed eigenvector */ +- +- gsl_matrix *Q; /* pointer to left Schur vectors */ +- gsl_matrix *Z; /* pointer to right Schur vectors */ +- +- gsl_eigen_gen_workspace *gen_workspace_p; +-} gsl_eigen_genv_workspace; +- +-gsl_eigen_genv_workspace * gsl_eigen_genv_alloc (const size_t n); +-void gsl_eigen_genv_free (gsl_eigen_genv_workspace * w); +-int gsl_eigen_genv (gsl_matrix * A, gsl_matrix * B, +- gsl_vector_complex * alpha, gsl_vector * beta, +- gsl_matrix_complex * evec, +- gsl_eigen_genv_workspace * w); +-int gsl_eigen_genv_QZ (gsl_matrix * A, gsl_matrix * B, +- gsl_vector_complex * alpha, gsl_vector * beta, +- gsl_matrix_complex * evec, +- gsl_matrix * Q, gsl_matrix * Z, +- gsl_eigen_genv_workspace * w); +- +- +- +-typedef enum { +- GSL_EIGEN_SORT_VAL_ASC, +- GSL_EIGEN_SORT_VAL_DESC, +- GSL_EIGEN_SORT_ABS_ASC, +- GSL_EIGEN_SORT_ABS_DESC +-} +-gsl_eigen_sort_t; +- +-/* Sort eigensystem results based on eigenvalues. +- * Sorts in order of increasing value or increasing +- * absolute value. +- * +- * exceptions: GSL_EBADLEN +- */ +- +-int gsl_eigen_symmv_sort(gsl_vector * eval, gsl_matrix * evec, +- gsl_eigen_sort_t sort_type); +- +-int gsl_eigen_hermv_sort(gsl_vector * eval, gsl_matrix_complex * evec, +- gsl_eigen_sort_t sort_type); +- +-int gsl_eigen_nonsymmv_sort(gsl_vector_complex * eval, +- gsl_matrix_complex * evec, +- gsl_eigen_sort_t sort_type); +- +-int gsl_eigen_gensymmv_sort (gsl_vector * eval, gsl_matrix * evec, +- gsl_eigen_sort_t sort_type); +- +-int gsl_eigen_genhermv_sort (gsl_vector * eval, gsl_matrix_complex * evec, +- gsl_eigen_sort_t sort_type); +- +-int gsl_eigen_genv_sort (gsl_vector_complex * alpha, gsl_vector * beta, +- gsl_matrix_complex * evec, +- gsl_eigen_sort_t sort_type); +- +-/* Prototypes for the schur module */ +- +-int gsl_schur_gen_eigvals(const gsl_matrix *A, const gsl_matrix *B, +- double *wr1, double *wr2, double *wi, +- double *scale1, double *scale2); +- +-int gsl_schur_solve_equation(double ca, const gsl_matrix *A, double z, +- double d1, double d2, const gsl_vector *b, +- gsl_vector *x, double *s, double *xnorm, +- double smin); +- +-int gsl_schur_solve_equation_z(double ca, const gsl_matrix *A, +- gsl_complex *z, double d1, double d2, +- const gsl_vector_complex *b, +- gsl_vector_complex *x, double *s, +- double *xnorm, double smin); +- +- +-/* The following functions are obsolete: */ +- +-/* Eigensolve by Jacobi Method +- * +- * The data in the matrix input is destroyed. +- * +- * exceptions: +- */ +-int +-gsl_eigen_jacobi(gsl_matrix * matrix, +- gsl_vector * eval, +- gsl_matrix * evec, +- unsigned int max_rot, +- unsigned int * nrot); +- +- +-/* Invert by Jacobi Method +- * +- * exceptions: +- */ +-int +-gsl_eigen_invert_jacobi(const gsl_matrix * matrix, +- gsl_matrix * ainv, +- unsigned int max_rot); +- +- +- +-__END_DECLS +- +-#endif /* __GSL_EIGEN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_long.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_LONG_H__ +-#define __GSL_SORT_VECTOR_LONG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_long (gsl_vector_long * v); +-int gsl_sort_vector_long_index (gsl_permutation * p, const gsl_vector_long * v); +- +-int gsl_sort_vector_long_smallest (long * dest, const size_t k, const gsl_vector_long * v); +-int gsl_sort_vector_long_largest (long * dest, const size_t k, const gsl_vector_long * v); +- +-int gsl_sort_vector_long_smallest_index (size_t * p, const size_t k, const gsl_vector_long * v); +-int gsl_sort_vector_long_largest_index (size_t * p, const size_t k, const gsl_vector_long * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_spline.h (revision 14079) +@@ -1,101 +0,0 @@ +-/* interpolation/gsl_spline.h +- * +- * Copyright (C) 2001, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SPLINE_H__ +-#define __GSL_SPLINE_H__ +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* general interpolation object */ +-typedef struct { +- gsl_interp * interp; +- double * x; +- double * y; +- size_t size; +-} gsl_spline; +- +-gsl_spline * +-gsl_spline_alloc(const gsl_interp_type * T, size_t size); +- +-int +-gsl_spline_init(gsl_spline * spline, const double xa[], const double ya[], size_t size); +- +-const char * gsl_spline_name(const gsl_spline * spline); +-unsigned int gsl_spline_min_size(const gsl_spline * spline); +- +- +-int +-gsl_spline_eval_e(const gsl_spline * spline, double x, +- gsl_interp_accel * a, double * y); +- +-double +-gsl_spline_eval(const gsl_spline * spline, double x, gsl_interp_accel * a); +- +-int +-gsl_spline_eval_deriv_e(const gsl_spline * spline, +- double x, +- gsl_interp_accel * a, +- double * y); +- +-double +-gsl_spline_eval_deriv(const gsl_spline * spline, +- double x, +- gsl_interp_accel * a); +- +-int +-gsl_spline_eval_deriv2_e(const gsl_spline * spline, +- double x, +- gsl_interp_accel * a, +- double * y); +- +-double +-gsl_spline_eval_deriv2(const gsl_spline * spline, +- double x, +- gsl_interp_accel * a); +- +-int +-gsl_spline_eval_integ_e(const gsl_spline * spline, +- double a, double b, +- gsl_interp_accel * acc, +- double * y); +- +-double +-gsl_spline_eval_integ(const gsl_spline * spline, +- double a, double b, +- gsl_interp_accel * acc); +- +-void +-gsl_spline_free(gsl_spline * spline); +- +-__END_DECLS +- +-#endif /* __GSL_INTERP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_bspline.h (revision 14079) +@@ -1,114 +0,0 @@ +-/* bspline/gsl_bspline.h +- * +- * Copyright (C) 2006 Patrick Alken +- * Copyright (C) 2008 Rhys Ulerich +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BSPLINE_H__ +-#define __GSL_BSPLINE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t k; /* spline order */ +- size_t km1; /* k - 1 (polynomial order) */ +- size_t l; /* number of polynomial pieces on interval */ +- size_t nbreak; /* number of breakpoints (l + 1) */ +- size_t n; /* number of bspline basis functions (l + k - 1) */ +- +- gsl_vector *knots; /* knots vector */ +- gsl_vector *deltal; /* left delta */ +- gsl_vector *deltar; /* right delta */ +- gsl_vector *B; /* temporary spline results */ +-} gsl_bspline_workspace; +- +-typedef struct +-{ +- size_t k; /* spline order */ +- gsl_matrix *A; /* work matrix */ +- gsl_matrix *dB; /* temporary derivative results */ +-} gsl_bspline_deriv_workspace; +- +-gsl_bspline_workspace * +-gsl_bspline_alloc(const size_t k, const size_t nbreak); +- +-void gsl_bspline_free(gsl_bspline_workspace *w); +- +-size_t gsl_bspline_ncoeffs(gsl_bspline_workspace * w); +-size_t gsl_bspline_order(gsl_bspline_workspace * w); +-size_t gsl_bspline_nbreak(gsl_bspline_workspace * w); +-double gsl_bspline_breakpoint(size_t i, gsl_bspline_workspace * w); +-double gsl_bspline_greville_abscissa(size_t i, gsl_bspline_workspace *w); +- +-int +-gsl_bspline_knots(const gsl_vector *breakpts, gsl_bspline_workspace *w); +- +-int gsl_bspline_knots_uniform(const double a, const double b, +- gsl_bspline_workspace *w); +- +-int +-gsl_bspline_eval(const double x, gsl_vector *B, +- gsl_bspline_workspace *w); +- +-int +-gsl_bspline_eval_nonzero(const double x, +- gsl_vector *Bk, +- size_t *istart, +- size_t *iend, +- gsl_bspline_workspace *w); +- +-gsl_bspline_deriv_workspace * +-gsl_bspline_deriv_alloc(const size_t k); +- +-void +-gsl_bspline_deriv_free(gsl_bspline_deriv_workspace *w); +- +-int +-gsl_bspline_deriv_eval(const double x, +- const size_t nderiv, +- gsl_matrix *dB, +- gsl_bspline_workspace *w, +- gsl_bspline_deriv_workspace *dw); +- +-int +-gsl_bspline_deriv_eval_nonzero(const double x, +- const size_t nderiv, +- gsl_matrix *dB, +- size_t *istart, +- size_t *iend, +- gsl_bspline_workspace *w, +- gsl_bspline_deriv_workspace *dw); +- +-__END_DECLS +- +-#endif /* __GSL_BSPLINE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_trig.h (revision 14079) +@@ -1,152 +0,0 @@ +-/* specfunc/gsl_sf_trig.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_TRIG_H__ +-#define __GSL_SF_TRIG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Sin(x) with GSL semantics. This is actually important +- * because we want to control the error estimate, and trying +- * to guess the error for the standard library implementation +- * every time it is used would be a little goofy. +- */ +-int gsl_sf_sin_e(double x, gsl_sf_result * result); +-double gsl_sf_sin(const double x); +- +- +-/* Cos(x) with GSL semantics. +- */ +-int gsl_sf_cos_e(double x, gsl_sf_result * result); +-double gsl_sf_cos(const double x); +- +- +-/* Hypot(x,y) with GSL semantics. +- */ +-int gsl_sf_hypot_e(const double x, const double y, gsl_sf_result * result); +-double gsl_sf_hypot(const double x, const double y); +- +- +-/* Sin(z) for complex z +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_complex_sin_e(const double zr, const double zi, gsl_sf_result * szr, gsl_sf_result * szi); +- +- +-/* Cos(z) for complex z +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_complex_cos_e(const double zr, const double zi, gsl_sf_result * czr, gsl_sf_result * czi); +- +- +-/* Log(Sin(z)) for complex z +- * +- * exceptions: GSL_EDOM, GSL_ELOSS +- */ +-int gsl_sf_complex_logsin_e(const double zr, const double zi, gsl_sf_result * lszr, gsl_sf_result * lszi); +- +- +-/* Sinc(x) = sin(pi x) / (pi x) +- * +- * exceptions: none +- */ +-int gsl_sf_sinc_e(double x, gsl_sf_result * result); +-double gsl_sf_sinc(const double x); +- +- +-/* Log(Sinh(x)), x > 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_lnsinh_e(const double x, gsl_sf_result * result); +-double gsl_sf_lnsinh(const double x); +- +- +-/* Log(Cosh(x)) +- * +- * exceptions: none +- */ +-int gsl_sf_lncosh_e(const double x, gsl_sf_result * result); +-double gsl_sf_lncosh(const double x); +- +- +-/* Convert polar to rectlinear coordinates. +- * +- * exceptions: GSL_ELOSS +- */ +-int gsl_sf_polar_to_rect(const double r, const double theta, gsl_sf_result * x, gsl_sf_result * y); +- +-/* Convert rectilinear to polar coordinates. +- * return argument in range [-pi, pi] +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_rect_to_polar(const double x, const double y, gsl_sf_result * r, gsl_sf_result * theta); +- +-/* Sin(x) for quantity with an associated error. +- */ +-int gsl_sf_sin_err_e(const double x, const double dx, gsl_sf_result * result); +- +- +-/* Cos(x) for quantity with an associated error. +- */ +-int gsl_sf_cos_err_e(const double x, const double dx, gsl_sf_result * result); +- +- +-/* Force an angle to lie in the range (-pi,pi]. +- * +- * exceptions: GSL_ELOSS +- */ +-int gsl_sf_angle_restrict_symm_e(double * theta); +-double gsl_sf_angle_restrict_symm(const double theta); +- +- +-/* Force an angle to lie in the range [0, 2pi) +- * +- * exceptions: GSL_ELOSS +- */ +-int gsl_sf_angle_restrict_pos_e(double * theta); +-double gsl_sf_angle_restrict_pos(const double theta); +- +- +-int gsl_sf_angle_restrict_symm_err_e(const double theta, gsl_sf_result * result); +- +-int gsl_sf_angle_restrict_pos_err_e(const double theta, gsl_sf_result * result); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_TRIG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elementary.h (revision 14079) +@@ -1,57 +0,0 @@ +-/* specfunc/gsl_sf_elementary.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-/* Miscellaneous elementary functions and operations. +- */ +-#ifndef __GSL_SF_ELEMENTARY_H__ +-#define __GSL_SF_ELEMENTARY_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Multiplication. +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_multiply_e(const double x, const double y, gsl_sf_result * result); +-double gsl_sf_multiply(const double x, const double y); +- +- +-/* Multiplication of quantities with associated errors. +- */ +-int gsl_sf_multiply_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_ELEMENTARY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_ushort.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_USHORT_H__ +-#define __GSL_BLOCK_USHORT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_ushort_struct +-{ +- size_t size; +- unsigned short *data; +-}; +- +-typedef struct gsl_block_ushort_struct gsl_block_ushort; +- +-gsl_block_ushort *gsl_block_ushort_alloc (const size_t n); +-gsl_block_ushort *gsl_block_ushort_calloc (const size_t n); +-void gsl_block_ushort_free (gsl_block_ushort * b); +- +-int gsl_block_ushort_fread (FILE * stream, gsl_block_ushort * b); +-int gsl_block_ushort_fwrite (FILE * stream, const gsl_block_ushort * b); +-int gsl_block_ushort_fscanf (FILE * stream, gsl_block_ushort * b); +-int gsl_block_ushort_fprintf (FILE * stream, const gsl_block_ushort * b, const char *format); +- +-int gsl_block_ushort_raw_fread (FILE * stream, unsigned short * b, const size_t n, const size_t stride); +-int gsl_block_ushort_raw_fwrite (FILE * stream, const unsigned short * b, const size_t n, const size_t stride); +-int gsl_block_ushort_raw_fscanf (FILE * stream, unsigned short * b, const size_t n, const size_t stride); +-int gsl_block_ushort_raw_fprintf (FILE * stream, const unsigned short * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_ushort_size (const gsl_block_ushort * b); +-unsigned short * gsl_block_ushort_data (const gsl_block_ushort * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_laguerre.h (revision 14079) +@@ -1,68 +0,0 @@ +-/* specfunc/gsl_sf_laguerre.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_LAGUERRE_H__ +-#define __GSL_SF_LAGUERRE_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* L^a_n(x) = (a+1)_n / n! 1F1(-n,a+1,x) */ +- +- +-/* Evaluate generalized Laguerre polynomials +- * using explicit representations. +- * +- * exceptions: none +- */ +-int gsl_sf_laguerre_1_e(const double a, const double x, gsl_sf_result * result); +-int gsl_sf_laguerre_2_e(const double a, const double x, gsl_sf_result * result); +-int gsl_sf_laguerre_3_e(const double a, const double x, gsl_sf_result * result); +-double gsl_sf_laguerre_1(double a, double x); +-double gsl_sf_laguerre_2(double a, double x); +-double gsl_sf_laguerre_3(double a, double x); +- +- +-/* Evaluate generalized Laguerre polynomials. +- * +- * a > -1.0 +- * n >= 0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_laguerre_n_e(const int n, const double a, const double x, gsl_sf_result * result); +-double gsl_sf_laguerre_n(int n, double a, double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_LAGUERRE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_float.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_FLOAT_H__ +-#define __GSL_SORT_VECTOR_FLOAT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_float (gsl_vector_float * v); +-int gsl_sort_vector_float_index (gsl_permutation * p, const gsl_vector_float * v); +- +-int gsl_sort_vector_float_smallest (float * dest, const size_t k, const gsl_vector_float * v); +-int gsl_sort_vector_float_largest (float * dest, const size_t k, const gsl_vector_float * v); +- +-int gsl_sort_vector_float_smallest_index (size_t * p, const size_t k, const gsl_vector_float * v); +-int gsl_sort_vector_float_largest_index (size_t * p, const size_t k, const gsl_vector_float * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mks.h (revision 14079) +@@ -1,126 +0,0 @@ +-/* const/gsl_const_mks.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- * 2006, 2007, 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST_MKS__ +-#define __GSL_CONST_MKS__ +- +-#define GSL_CONST_MKS_SPEED_OF_LIGHT (2.99792458e8) /* m / s */ +-#define GSL_CONST_MKS_GRAVITATIONAL_CONSTANT (6.673e-11) /* m^3 / kg s^2 */ +-#define GSL_CONST_MKS_PLANCKS_CONSTANT_H (6.62606896e-34) /* kg m^2 / s */ +-#define GSL_CONST_MKS_PLANCKS_CONSTANT_HBAR (1.05457162825e-34) /* kg m^2 / s */ +-#define GSL_CONST_MKS_ASTRONOMICAL_UNIT (1.49597870691e11) /* m */ +-#define GSL_CONST_MKS_LIGHT_YEAR (9.46053620707e15) /* m */ +-#define GSL_CONST_MKS_PARSEC (3.08567758135e16) /* m */ +-#define GSL_CONST_MKS_GRAV_ACCEL (9.80665e0) /* m / s^2 */ +-#define GSL_CONST_MKS_ELECTRON_VOLT (1.602176487e-19) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_MASS_ELECTRON (9.10938188e-31) /* kg */ +-#define GSL_CONST_MKS_MASS_MUON (1.88353109e-28) /* kg */ +-#define GSL_CONST_MKS_MASS_PROTON (1.67262158e-27) /* kg */ +-#define GSL_CONST_MKS_MASS_NEUTRON (1.67492716e-27) /* kg */ +-#define GSL_CONST_MKS_RYDBERG (2.17987196968e-18) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_BOLTZMANN (1.3806504e-23) /* kg m^2 / K s^2 */ +-#define GSL_CONST_MKS_MOLAR_GAS (8.314472e0) /* kg m^2 / K mol s^2 */ +-#define GSL_CONST_MKS_STANDARD_GAS_VOLUME (2.2710981e-2) /* m^3 / mol */ +-#define GSL_CONST_MKS_MINUTE (6e1) /* s */ +-#define GSL_CONST_MKS_HOUR (3.6e3) /* s */ +-#define GSL_CONST_MKS_DAY (8.64e4) /* s */ +-#define GSL_CONST_MKS_WEEK (6.048e5) /* s */ +-#define GSL_CONST_MKS_INCH (2.54e-2) /* m */ +-#define GSL_CONST_MKS_FOOT (3.048e-1) /* m */ +-#define GSL_CONST_MKS_YARD (9.144e-1) /* m */ +-#define GSL_CONST_MKS_MILE (1.609344e3) /* m */ +-#define GSL_CONST_MKS_NAUTICAL_MILE (1.852e3) /* m */ +-#define GSL_CONST_MKS_FATHOM (1.8288e0) /* m */ +-#define GSL_CONST_MKS_MIL (2.54e-5) /* m */ +-#define GSL_CONST_MKS_POINT (3.52777777778e-4) /* m */ +-#define GSL_CONST_MKS_TEXPOINT (3.51459803515e-4) /* m */ +-#define GSL_CONST_MKS_MICRON (1e-6) /* m */ +-#define GSL_CONST_MKS_ANGSTROM (1e-10) /* m */ +-#define GSL_CONST_MKS_HECTARE (1e4) /* m^2 */ +-#define GSL_CONST_MKS_ACRE (4.04685642241e3) /* m^2 */ +-#define GSL_CONST_MKS_BARN (1e-28) /* m^2 */ +-#define GSL_CONST_MKS_LITER (1e-3) /* m^3 */ +-#define GSL_CONST_MKS_US_GALLON (3.78541178402e-3) /* m^3 */ +-#define GSL_CONST_MKS_QUART (9.46352946004e-4) /* m^3 */ +-#define GSL_CONST_MKS_PINT (4.73176473002e-4) /* m^3 */ +-#define GSL_CONST_MKS_CUP (2.36588236501e-4) /* m^3 */ +-#define GSL_CONST_MKS_FLUID_OUNCE (2.95735295626e-5) /* m^3 */ +-#define GSL_CONST_MKS_TABLESPOON (1.47867647813e-5) /* m^3 */ +-#define GSL_CONST_MKS_TEASPOON (4.92892159375e-6) /* m^3 */ +-#define GSL_CONST_MKS_CANADIAN_GALLON (4.54609e-3) /* m^3 */ +-#define GSL_CONST_MKS_UK_GALLON (4.546092e-3) /* m^3 */ +-#define GSL_CONST_MKS_MILES_PER_HOUR (4.4704e-1) /* m / s */ +-#define GSL_CONST_MKS_KILOMETERS_PER_HOUR (2.77777777778e-1) /* m / s */ +-#define GSL_CONST_MKS_KNOT (5.14444444444e-1) /* m / s */ +-#define GSL_CONST_MKS_POUND_MASS (4.5359237e-1) /* kg */ +-#define GSL_CONST_MKS_OUNCE_MASS (2.8349523125e-2) /* kg */ +-#define GSL_CONST_MKS_TON (9.0718474e2) /* kg */ +-#define GSL_CONST_MKS_METRIC_TON (1e3) /* kg */ +-#define GSL_CONST_MKS_UK_TON (1.0160469088e3) /* kg */ +-#define GSL_CONST_MKS_TROY_OUNCE (3.1103475e-2) /* kg */ +-#define GSL_CONST_MKS_CARAT (2e-4) /* kg */ +-#define GSL_CONST_MKS_UNIFIED_ATOMIC_MASS (1.660538782e-27) /* kg */ +-#define GSL_CONST_MKS_GRAM_FORCE (9.80665e-3) /* kg m / s^2 */ +-#define GSL_CONST_MKS_POUND_FORCE (4.44822161526e0) /* kg m / s^2 */ +-#define GSL_CONST_MKS_KILOPOUND_FORCE (4.44822161526e3) /* kg m / s^2 */ +-#define GSL_CONST_MKS_POUNDAL (1.38255e-1) /* kg m / s^2 */ +-#define GSL_CONST_MKS_CALORIE (4.1868e0) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_BTU (1.05505585262e3) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_THERM (1.05506e8) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_HORSEPOWER (7.457e2) /* kg m^2 / s^3 */ +-#define GSL_CONST_MKS_BAR (1e5) /* kg / m s^2 */ +-#define GSL_CONST_MKS_STD_ATMOSPHERE (1.01325e5) /* kg / m s^2 */ +-#define GSL_CONST_MKS_TORR (1.33322368421e2) /* kg / m s^2 */ +-#define GSL_CONST_MKS_METER_OF_MERCURY (1.33322368421e5) /* kg / m s^2 */ +-#define GSL_CONST_MKS_INCH_OF_MERCURY (3.38638815789e3) /* kg / m s^2 */ +-#define GSL_CONST_MKS_INCH_OF_WATER (2.490889e2) /* kg / m s^2 */ +-#define GSL_CONST_MKS_PSI (6.89475729317e3) /* kg / m s^2 */ +-#define GSL_CONST_MKS_POISE (1e-1) /* kg m^-1 s^-1 */ +-#define GSL_CONST_MKS_STOKES (1e-4) /* m^2 / s */ +-#define GSL_CONST_MKS_STILB (1e4) /* cd / m^2 */ +-#define GSL_CONST_MKS_LUMEN (1e0) /* cd sr */ +-#define GSL_CONST_MKS_LUX (1e0) /* cd sr / m^2 */ +-#define GSL_CONST_MKS_PHOT (1e4) /* cd sr / m^2 */ +-#define GSL_CONST_MKS_FOOTCANDLE (1.076e1) /* cd sr / m^2 */ +-#define GSL_CONST_MKS_LAMBERT (1e4) /* cd sr / m^2 */ +-#define GSL_CONST_MKS_FOOTLAMBERT (1.07639104e1) /* cd sr / m^2 */ +-#define GSL_CONST_MKS_CURIE (3.7e10) /* 1 / s */ +-#define GSL_CONST_MKS_ROENTGEN (2.58e-4) /* A s / kg */ +-#define GSL_CONST_MKS_RAD (1e-2) /* m^2 / s^2 */ +-#define GSL_CONST_MKS_SOLAR_MASS (1.98892e30) /* kg */ +-#define GSL_CONST_MKS_BOHR_RADIUS (5.291772083e-11) /* m */ +-#define GSL_CONST_MKS_NEWTON (1e0) /* kg m / s^2 */ +-#define GSL_CONST_MKS_DYNE (1e-5) /* kg m / s^2 */ +-#define GSL_CONST_MKS_JOULE (1e0) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_ERG (1e-7) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKS_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-8) /* kg / K^4 s^3 */ +-#define GSL_CONST_MKS_THOMSON_CROSS_SECTION (6.65245893699e-29) /* m^2 */ +-#define GSL_CONST_MKS_BOHR_MAGNETON (9.27400899e-24) /* A m^2 */ +-#define GSL_CONST_MKS_NUCLEAR_MAGNETON (5.05078317e-27) /* A m^2 */ +-#define GSL_CONST_MKS_ELECTRON_MAGNETIC_MOMENT (9.28476362e-24) /* A m^2 */ +-#define GSL_CONST_MKS_PROTON_MAGNETIC_MOMENT (1.410606633e-26) /* A m^2 */ +-#define GSL_CONST_MKS_FARADAY (9.64853429775e4) /* A s / mol */ +-#define GSL_CONST_MKS_ELECTRON_CHARGE (1.602176487e-19) /* A s */ +-#define GSL_CONST_MKS_VACUUM_PERMITTIVITY (8.854187817e-12) /* A^2 s^4 / kg m^3 */ +-#define GSL_CONST_MKS_VACUUM_PERMEABILITY (1.25663706144e-6) /* kg m / A^2 s^2 */ +-#define GSL_CONST_MKS_DEBYE (3.33564095198e-30) /* A s^2 / m^2 */ +-#define GSL_CONST_MKS_GAUSS (1e-4) /* kg / A s^2 */ +- +-#endif /* __GSL_CONST_MKS__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_interp.h (revision 14079) +@@ -1,224 +0,0 @@ +-/* interpolation/gsl_interp.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman +- */ +-#ifndef __GSL_INTERP_H__ +-#define __GSL_INTERP_H__ +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* evaluation accelerator */ +-typedef struct { +- size_t cache; /* cache of index */ +- size_t miss_count; /* keep statistics */ +- size_t hit_count; +-} +-gsl_interp_accel; +- +- +-/* interpolation object type */ +-typedef struct { +- const char * name; +- unsigned int min_size; +- void * (*alloc) (size_t size); +- int (*init) (void *, const double xa[], const double ya[], size_t size); +- int (*eval) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y); +- int (*eval_deriv) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_p); +- int (*eval_deriv2) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_pp); +- int (*eval_integ) (const void *, const double xa[], const double ya[], size_t size, gsl_interp_accel *, double a, double b, double * result); +- void (*free) (void *); +- +-} gsl_interp_type; +- +- +-/* general interpolation object */ +-typedef struct { +- const gsl_interp_type * type; +- double xmin; +- double xmax; +- size_t size; +- void * state; +-} gsl_interp; +- +- +-/* available types */ +-GSL_VAR const gsl_interp_type * gsl_interp_linear; +-GSL_VAR const gsl_interp_type * gsl_interp_polynomial; +-GSL_VAR const gsl_interp_type * gsl_interp_cspline; +-GSL_VAR const gsl_interp_type * gsl_interp_cspline_periodic; +-GSL_VAR const gsl_interp_type * gsl_interp_akima; +-GSL_VAR const gsl_interp_type * gsl_interp_akima_periodic; +- +-gsl_interp_accel * +-gsl_interp_accel_alloc(void); +- +-int +-gsl_interp_accel_reset (gsl_interp_accel * a); +- +-void +-gsl_interp_accel_free(gsl_interp_accel * a); +- +-gsl_interp * +-gsl_interp_alloc(const gsl_interp_type * T, size_t n); +- +-int +-gsl_interp_init(gsl_interp * obj, const double xa[], const double ya[], size_t size); +- +-const char * gsl_interp_name(const gsl_interp * interp); +-unsigned int gsl_interp_min_size(const gsl_interp * interp); +-unsigned int gsl_interp_type_min_size(const gsl_interp_type * T); +- +- +-int +-gsl_interp_eval_e(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a, double * y); +- +-double +-gsl_interp_eval(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a); +- +-int +-gsl_interp_eval_deriv_e(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a, +- double * d); +- +-double +-gsl_interp_eval_deriv(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a); +- +-int +-gsl_interp_eval_deriv2_e(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a, +- double * d2); +- +-double +-gsl_interp_eval_deriv2(const gsl_interp * obj, +- const double xa[], const double ya[], double x, +- gsl_interp_accel * a); +- +-int +-gsl_interp_eval_integ_e(const gsl_interp * obj, +- const double xa[], const double ya[], +- double a, double b, +- gsl_interp_accel * acc, +- double * result); +- +-double +-gsl_interp_eval_integ(const gsl_interp * obj, +- const double xa[], const double ya[], +- double a, double b, +- gsl_interp_accel * acc); +- +-void +-gsl_interp_free(gsl_interp * interp); +- +-INLINE_DECL size_t +-gsl_interp_bsearch(const double x_array[], double x, +- size_t index_lo, size_t index_hi); +- +-#ifdef HAVE_INLINE +- +-/* Perform a binary search of an array of values. +- * +- * The parameters index_lo and index_hi provide an initial bracket, +- * and it is assumed that index_lo < index_hi. The resulting index +- * is guaranteed to be strictly less than index_hi and greater than +- * or equal to index_lo, so that the implicit bracket [index, index+1] +- * always corresponds to a region within the implicit value range of +- * the value array. +- * +- * Note that this means the relationship of 'x' to x_array[index] +- * and x_array[index+1] depends on the result region, i.e. the +- * behaviour at the boundaries may not correspond to what you +- * expect. We have the following complete specification of the +- * behaviour. +- * Suppose the input is x_array[] = { x0, x1, ..., xN } +- * if ( x == x0 ) then index == 0 +- * if ( x > x0 && x <= x1 ) then index == 0, and sim. for other interior pts +- * if ( x == xN ) then index == N-1 +- * if ( x > xN ) then index == N-1 +- * if ( x < x0 ) then index == 0 +- */ +- +-INLINE_FUN size_t +-gsl_interp_bsearch(const double x_array[], double x, +- size_t index_lo, size_t index_hi) +-{ +- size_t ilo = index_lo; +- size_t ihi = index_hi; +- while(ihi > ilo + 1) { +- size_t i = (ihi + ilo)/2; +- if(x_array[i] > x) +- ihi = i; +- else +- ilo = i; +- } +- +- return ilo; +-} +-#endif +- +-INLINE_DECL size_t +-gsl_interp_accel_find(gsl_interp_accel * a, const double x_array[], size_t size, double x); +- +-#ifdef HAVE_INLINE +-INLINE_FUN size_t +-gsl_interp_accel_find(gsl_interp_accel * a, const double xa[], size_t len, double x) +-{ +- size_t x_index = a->cache; +- +- if(x < xa[x_index]) { +- a->miss_count++; +- a->cache = gsl_interp_bsearch(xa, x, 0, x_index); +- } +- else if(x >= xa[x_index + 1]) { +- a->miss_count++; +- a->cache = gsl_interp_bsearch(xa, x, x_index, len-1); +- } +- else { +- a->hit_count++; +- } +- +- return a->cache; +-} +-#endif /* HAVE_INLINE */ +- +- +-__END_DECLS +- +-#endif /* __GSL_INTERP_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long_double.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_LONG_DOUBLE_H__ +-#define __GSL_BLOCK_LONG_DOUBLE_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_long_double_struct +-{ +- size_t size; +- long double *data; +-}; +- +-typedef struct gsl_block_long_double_struct gsl_block_long_double; +- +-gsl_block_long_double *gsl_block_long_double_alloc (const size_t n); +-gsl_block_long_double *gsl_block_long_double_calloc (const size_t n); +-void gsl_block_long_double_free (gsl_block_long_double * b); +- +-int gsl_block_long_double_fread (FILE * stream, gsl_block_long_double * b); +-int gsl_block_long_double_fwrite (FILE * stream, const gsl_block_long_double * b); +-int gsl_block_long_double_fscanf (FILE * stream, gsl_block_long_double * b); +-int gsl_block_long_double_fprintf (FILE * stream, const gsl_block_long_double * b, const char *format); +- +-int gsl_block_long_double_raw_fread (FILE * stream, long double * b, const size_t n, const size_t stride); +-int gsl_block_long_double_raw_fwrite (FILE * stream, const long double * b, const size_t n, const size_t stride); +-int gsl_block_long_double_raw_fscanf (FILE * stream, long double * b, const size_t n, const size_t stride); +-int gsl_block_long_double_raw_fprintf (FILE * stream, const long double * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_long_double_size (const gsl_block_long_double * b); +-long double * gsl_block_long_double_data (const gsl_block_long_double * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_erf.h (revision 14079) +@@ -1,91 +0,0 @@ +-/* specfunc/gsl_sf_erf.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_ERF_H__ +-#define __GSL_SF_ERF_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Complementary Error Function +- * erfc(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,x,Infinity}] +- * +- * exceptions: none +- */ +-int gsl_sf_erfc_e(double x, gsl_sf_result * result); +-double gsl_sf_erfc(double x); +- +- +-/* Log Complementary Error Function +- * +- * exceptions: none +- */ +-int gsl_sf_log_erfc_e(double x, gsl_sf_result * result); +-double gsl_sf_log_erfc(double x); +- +- +-/* Error Function +- * erf(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,0,x}] +- * +- * exceptions: none +- */ +-int gsl_sf_erf_e(double x, gsl_sf_result * result); +-double gsl_sf_erf(double x); +- +- +-/* Probability functions: +- * Z(x) : Abramowitz+Stegun 26.2.1 +- * Q(x) : Abramowitz+Stegun 26.2.3 +- * +- * exceptions: none +- */ +-int gsl_sf_erf_Z_e(double x, gsl_sf_result * result); +-int gsl_sf_erf_Q_e(double x, gsl_sf_result * result); +-double gsl_sf_erf_Z(double x); +-double gsl_sf_erf_Q(double x); +- +- +-/* Hazard function, also known as the inverse Mill's ratio. +- * +- * H(x) := Z(x)/Q(x) +- * = Sqrt[2/Pi] Exp[-x^2 / 2] / Erfc[x/Sqrt[2]] +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_hazard_e(double x, gsl_sf_result * result); +-double gsl_sf_hazard(double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_ERF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ntuple.h (revision 14079) +@@ -1,82 +0,0 @@ +-/* histogram/ntuple.h +- * +- * Copyright (C) 2000 Simone Piccardi +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- * +- */ +- +-/* Jan/2001 Modified by Brian Gough. Minor changes for GSL */ +- +-#ifndef __GSL_NTUPLE_H__ +-#define __GSL_NTUPLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- FILE * file; +- void * ntuple_data; +- size_t size; +-} gsl_ntuple; +- +-typedef struct { +- int (* function) (void * ntuple_data, void * params); +- void * params; +-} gsl_ntuple_select_fn; +- +-typedef struct { +- double (* function) (void * ntuple_data, void * params); +- void * params; +-} gsl_ntuple_value_fn; +- +-gsl_ntuple * +-gsl_ntuple_open (char * filename, void * ntuple_data, size_t size); +- +-gsl_ntuple * +-gsl_ntuple_create (char * filename, void * ntuple_data, size_t size); +- +-int gsl_ntuple_write (gsl_ntuple * ntuple); +-int gsl_ntuple_read (gsl_ntuple * ntuple); +- +-int gsl_ntuple_bookdata (gsl_ntuple * ntuple); /* synonym for write */ +- +-int gsl_ntuple_project (gsl_histogram * h, gsl_ntuple * ntuple, +- gsl_ntuple_value_fn *value_func, +- gsl_ntuple_select_fn *select_func); +- +-int gsl_ntuple_close (gsl_ntuple * ntuple); +- +-__END_DECLS +- +-#endif /* __GSL_NTUPLE_H__ */ +- +- +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_pow_int.h (revision 14079) +@@ -1,49 +0,0 @@ +-/* specfunc/gsl_sf_pow_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_POW_INT_H__ +-#define __GSL_SF_POW_INT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Calculate x^n. +- * Does not check for overflow/underflow. +- */ +-int gsl_sf_pow_int_e(double x, int n, gsl_sf_result * result); +-double gsl_sf_pow_int(const double x, const int n); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ushort.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_USHORT_H__ +-#define __GSL_PERMUTE_VECTOR_USHORT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_ushort (const gsl_permutation * p, gsl_vector_ushort * v); +-int gsl_permute_vector_ushort_inverse (const gsl_permutation * p, gsl_vector_ushort * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_siman.h (revision 14079) +@@ -1,82 +0,0 @@ +-/* siman/gsl_siman.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Mark Galassi +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SIMAN_H__ +-#define __GSL_SIMAN_H__ +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* types for the function pointers passed to gsl_siman_solve */ +- +-typedef double (*gsl_siman_Efunc_t) (void *xp); +-typedef void (*gsl_siman_step_t) (const gsl_rng *r, void *xp, double step_size); +-typedef double (*gsl_siman_metric_t) (void *xp, void *yp); +-typedef void (*gsl_siman_print_t) (void *xp); +-typedef void (*gsl_siman_copy_t) (void *source, void *dest); +-typedef void * (*gsl_siman_copy_construct_t) (void *xp); +-typedef void (*gsl_siman_destroy_t) (void *xp); +- +-/* this structure contains all the information needed to structure the +- search, beyond the energy function, the step function and the +- initial guess. */ +- +-typedef struct { +- int n_tries; /* how many points to try for each step */ +- int iters_fixed_T; /* how many iterations at each temperature? */ +- double step_size; /* max step size in the random walk */ +- /* the following parameters are for the Boltzmann distribution */ +- double k, t_initial, mu_t, t_min; +-} gsl_siman_params_t; +- +-/* prototype for the workhorse function */ +- +-void gsl_siman_solve(const gsl_rng * r, +- void *x0_p, gsl_siman_Efunc_t Ef, +- gsl_siman_step_t take_step, +- gsl_siman_metric_t distance, +- gsl_siman_print_t print_position, +- gsl_siman_copy_t copyfunc, +- gsl_siman_copy_construct_t copy_constructor, +- gsl_siman_destroy_t destructor, +- size_t element_size, +- gsl_siman_params_t params); +- +-void +-gsl_siman_solve_many (const gsl_rng * r, void *x0_p, gsl_siman_Efunc_t Ef, +- gsl_siman_step_t take_step, +- gsl_siman_metric_t distance, +- gsl_siman_print_t print_position, +- size_t element_size, +- gsl_siman_params_t params); +- +-__END_DECLS +- +-#endif /* __GSL_SIMAN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_ellint.h (revision 14079) +@@ -1,112 +0,0 @@ +-/* specfunc/gsl_sf_ellint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_ELLINT_H__ +-#define __GSL_SF_ELLINT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Legendre form of complete elliptic integrals +- * +- * K(k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}] +- * E(k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}] +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_ellint_Kcomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_Kcomp(double k, gsl_mode_t mode); +- +-int gsl_sf_ellint_Ecomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_Ecomp(double k, gsl_mode_t mode); +- +-int gsl_sf_ellint_Pcomp_e(double k, double n, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_Pcomp(double k, double n, gsl_mode_t mode); +- +-int gsl_sf_ellint_Dcomp_e(double k, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_Dcomp(double k, gsl_mode_t mode); +- +- +-/* Legendre form of incomplete elliptic integrals +- * +- * F(phi,k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] +- * E(phi,k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] +- * P(phi,k,n) = Integral[(1 + n Sin[t]^2)^(-1)/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] +- * D(phi,k,n) = R_D(1-Sin[phi]^2, 1-k^2 Sin[phi]^2, 1.0) +- * +- * F: [Carlson, Numerische Mathematik 33 (1979) 1, (4.1)] +- * E: [Carlson, ", (4.2)] +- * P: [Carlson, ", (4.3)] +- * D: [Carlson, ", (4.4)] +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_ellint_F_e(double phi, double k, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_F(double phi, double k, gsl_mode_t mode); +- +-int gsl_sf_ellint_E_e(double phi, double k, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_E(double phi, double k, gsl_mode_t mode); +- +-int gsl_sf_ellint_P_e(double phi, double k, double n, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_P(double phi, double k, double n, gsl_mode_t mode); +- +-int gsl_sf_ellint_D_e(double phi, double k, double n, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_D(double phi, double k, double n, gsl_mode_t mode); +- +- +-/* Carlson's symmetric basis of functions +- * +- * RC(x,y) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1)], {t,0,Inf}] +- * RD(x,y,z) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-3/2), {t,0,Inf}] +- * RF(x,y,z) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2), {t,0,Inf}] +- * RJ(x,y,z,p) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2) (t+p)^(-1), {t,0,Inf}] +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_ellint_RC_e(double x, double y, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_RC(double x, double y, gsl_mode_t mode); +- +-int gsl_sf_ellint_RD_e(double x, double y, double z, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_RD(double x, double y, double z, gsl_mode_t mode); +- +-int gsl_sf_ellint_RF_e(double x, double y, double z, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_RF(double x, double y, double z, gsl_mode_t mode); +- +-int gsl_sf_ellint_RJ_e(double x, double y, double z, double p, gsl_mode_t mode, gsl_sf_result * result); +-double gsl_sf_ellint_RJ(double x, double y, double z, double p, gsl_mode_t mode); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_ELLINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_float.h (revision 14079) +@@ -1,351 +0,0 @@ +-/* matrix/gsl_matrix_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_COMPLEX_FLOAT_H__ +-#define __GSL_MATRIX_COMPLEX_FLOAT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- float * data; +- gsl_block_complex_float * block; +- int owner; +-} gsl_matrix_complex_float ; +- +-typedef struct +-{ +- gsl_matrix_complex_float matrix; +-} _gsl_matrix_complex_float_view; +- +-typedef _gsl_matrix_complex_float_view gsl_matrix_complex_float_view; +- +-typedef struct +-{ +- gsl_matrix_complex_float matrix; +-} _gsl_matrix_complex_float_const_view; +- +-typedef const _gsl_matrix_complex_float_const_view gsl_matrix_complex_float_const_view; +- +- +-/* Allocation */ +- +-gsl_matrix_complex_float * +-gsl_matrix_complex_float_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex_float * +-gsl_matrix_complex_float_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex_float * +-gsl_matrix_complex_float_alloc_from_block (gsl_block_complex_float * b, +- const size_t offset, +- const size_t n1, const size_t n2, const size_t d2); +- +-gsl_matrix_complex_float * +-gsl_matrix_complex_float_alloc_from_matrix (gsl_matrix_complex_float * b, +- const size_t k1, const size_t k2, +- const size_t n1, const size_t n2); +- +-gsl_vector_complex_float * +-gsl_vector_complex_float_alloc_row_from_matrix (gsl_matrix_complex_float * m, +- const size_t i); +- +-gsl_vector_complex_float * +-gsl_vector_complex_float_alloc_col_from_matrix (gsl_matrix_complex_float * m, +- const size_t j); +- +-void gsl_matrix_complex_float_free (gsl_matrix_complex_float * m); +- +-/* Views */ +- +-_gsl_matrix_complex_float_view +-gsl_matrix_complex_float_submatrix (gsl_matrix_complex_float * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_row (gsl_matrix_complex_float * m, const size_t i); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_column (gsl_matrix_complex_float * m, const size_t j); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_diagonal (gsl_matrix_complex_float * m); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_subdiagonal (gsl_matrix_complex_float * m, const size_t k); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_superdiagonal (gsl_matrix_complex_float * m, const size_t k); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_subrow (gsl_matrix_complex_float * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_float_view +-gsl_matrix_complex_float_subcolumn (gsl_matrix_complex_float * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_float_view +-gsl_matrix_complex_float_view_array (float * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_float_view +-gsl_matrix_complex_float_view_array_with_tda (float * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_float_view +-gsl_matrix_complex_float_view_vector (gsl_vector_complex_float * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_float_view +-gsl_matrix_complex_float_view_vector_with_tda (gsl_vector_complex_float * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_complex_float_const_view +-gsl_matrix_complex_float_const_submatrix (const gsl_matrix_complex_float * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_row (const gsl_matrix_complex_float * m, +- const size_t i); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_column (const gsl_matrix_complex_float * m, +- const size_t j); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_diagonal (const gsl_matrix_complex_float * m); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_subdiagonal (const gsl_matrix_complex_float * m, +- const size_t k); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_superdiagonal (const gsl_matrix_complex_float * m, +- const size_t k); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_subrow (const gsl_matrix_complex_float * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_float_const_view +-gsl_matrix_complex_float_const_subcolumn (const gsl_matrix_complex_float * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_float_const_view +-gsl_matrix_complex_float_const_view_array (const float * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_float_const_view +-gsl_matrix_complex_float_const_view_array_with_tda (const float * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_float_const_view +-gsl_matrix_complex_float_const_view_vector (const gsl_vector_complex_float * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_float_const_view +-gsl_matrix_complex_float_const_view_vector_with_tda (const gsl_vector_complex_float * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_complex_float_set_zero (gsl_matrix_complex_float * m); +-void gsl_matrix_complex_float_set_identity (gsl_matrix_complex_float * m); +-void gsl_matrix_complex_float_set_all (gsl_matrix_complex_float * m, gsl_complex_float x); +- +-int gsl_matrix_complex_float_fread (FILE * stream, gsl_matrix_complex_float * m) ; +-int gsl_matrix_complex_float_fwrite (FILE * stream, const gsl_matrix_complex_float * m) ; +-int gsl_matrix_complex_float_fscanf (FILE * stream, gsl_matrix_complex_float * m); +-int gsl_matrix_complex_float_fprintf (FILE * stream, const gsl_matrix_complex_float * m, const char * format); +- +-int gsl_matrix_complex_float_memcpy(gsl_matrix_complex_float * dest, const gsl_matrix_complex_float * src); +-int gsl_matrix_complex_float_swap(gsl_matrix_complex_float * m1, gsl_matrix_complex_float * m2); +- +-int gsl_matrix_complex_float_swap_rows(gsl_matrix_complex_float * m, const size_t i, const size_t j); +-int gsl_matrix_complex_float_swap_columns(gsl_matrix_complex_float * m, const size_t i, const size_t j); +-int gsl_matrix_complex_float_swap_rowcol(gsl_matrix_complex_float * m, const size_t i, const size_t j); +- +-int gsl_matrix_complex_float_transpose (gsl_matrix_complex_float * m); +-int gsl_matrix_complex_float_transpose_memcpy (gsl_matrix_complex_float * dest, const gsl_matrix_complex_float * src); +- +-int gsl_matrix_complex_float_equal (const gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); +- +-int gsl_matrix_complex_float_isnull (const gsl_matrix_complex_float * m); +-int gsl_matrix_complex_float_ispos (const gsl_matrix_complex_float * m); +-int gsl_matrix_complex_float_isneg (const gsl_matrix_complex_float * m); +-int gsl_matrix_complex_float_isnonneg (const gsl_matrix_complex_float * m); +- +-int gsl_matrix_complex_float_add (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); +-int gsl_matrix_complex_float_sub (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); +-int gsl_matrix_complex_float_mul_elements (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); +-int gsl_matrix_complex_float_div_elements (gsl_matrix_complex_float * a, const gsl_matrix_complex_float * b); +-int gsl_matrix_complex_float_scale (gsl_matrix_complex_float * a, const gsl_complex_float x); +-int gsl_matrix_complex_float_add_constant (gsl_matrix_complex_float * a, const gsl_complex_float x); +-int gsl_matrix_complex_float_add_diagonal (gsl_matrix_complex_float * a, const gsl_complex_float x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_complex_float_get_row(gsl_vector_complex_float * v, const gsl_matrix_complex_float * m, const size_t i); +-int gsl_matrix_complex_float_get_col(gsl_vector_complex_float * v, const gsl_matrix_complex_float * m, const size_t j); +-int gsl_matrix_complex_float_set_row(gsl_matrix_complex_float * m, const size_t i, const gsl_vector_complex_float * v); +-int gsl_matrix_complex_float_set_col(gsl_matrix_complex_float * m, const size_t j, const gsl_vector_complex_float * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL gsl_complex_float gsl_matrix_complex_float_get(const gsl_matrix_complex_float * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_complex_float_set(gsl_matrix_complex_float * m, const size_t i, const size_t j, const gsl_complex_float x); +- +-INLINE_DECL gsl_complex_float * gsl_matrix_complex_float_ptr(gsl_matrix_complex_float * m, const size_t i, const size_t j); +-INLINE_DECL const gsl_complex_float * gsl_matrix_complex_float_const_ptr(const gsl_matrix_complex_float * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex_float +-gsl_matrix_complex_float_get(const gsl_matrix_complex_float * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- gsl_complex_float zero = {{0,0}}; +- +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; +- } +- } +-#endif +- return *(gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_complex_float_set(gsl_matrix_complex_float * m, +- const size_t i, const size_t j, const gsl_complex_float x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- *(gsl_complex_float *)(m->data + 2*(i * m->tda + j)) = x ; +-} +- +-INLINE_FUN +-gsl_complex_float * +-gsl_matrix_complex_float_ptr(gsl_matrix_complex_float * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const gsl_complex_float * +-gsl_matrix_complex_float_const_ptr(const gsl_matrix_complex_float * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const gsl_complex_float *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_debye.h (revision 14079) +@@ -1,91 +0,0 @@ +-/* specfunc/gsl_sf_debye.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +-/* augmented by D_5(x) and D_6(x) by Richard J. Mathar, 2005-11-08 */ +- +-#ifndef __GSL_SF_DEBYE_H__ +-#define __GSL_SF_DEBYE_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] */ +- +-/* D_1(x) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_debye_1_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_1(const double x); +- +- +-/* D_2(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_debye_2_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_2(const double x); +- +- +-/* D_3(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_debye_3_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_3(const double x); +- +- +-/* D_4(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_debye_4_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_4(const double x); +- +-/* D_5(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_debye_5_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_5(const double x); +- +-/* D_6(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_debye_6_e(const double x, gsl_sf_result * result); +-double gsl_sf_debye_6(const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_DEBYE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_short.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_SHORT_H__ +-#define __GSL_VECTOR_SHORT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- short *data; +- gsl_block_short *block; +- int owner; +-} +-gsl_vector_short; +- +-typedef struct +-{ +- gsl_vector_short vector; +-} _gsl_vector_short_view; +- +-typedef _gsl_vector_short_view gsl_vector_short_view; +- +-typedef struct +-{ +- gsl_vector_short vector; +-} _gsl_vector_short_const_view; +- +-typedef const _gsl_vector_short_const_view gsl_vector_short_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_short *gsl_vector_short_alloc (const size_t n); +-gsl_vector_short *gsl_vector_short_calloc (const size_t n); +- +-gsl_vector_short *gsl_vector_short_alloc_from_block (gsl_block_short * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_short *gsl_vector_short_alloc_from_vector (gsl_vector_short * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_short_free (gsl_vector_short * v); +- +-/* Views */ +- +-_gsl_vector_short_view +-gsl_vector_short_view_array (short *v, size_t n); +- +-_gsl_vector_short_view +-gsl_vector_short_view_array_with_stride (short *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_short_const_view +-gsl_vector_short_const_view_array (const short *v, size_t n); +- +-_gsl_vector_short_const_view +-gsl_vector_short_const_view_array_with_stride (const short *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_short_view +-gsl_vector_short_subvector (gsl_vector_short *v, +- size_t i, +- size_t n); +- +-_gsl_vector_short_view +-gsl_vector_short_subvector_with_stride (gsl_vector_short *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_short_const_view +-gsl_vector_short_const_subvector (const gsl_vector_short *v, +- size_t i, +- size_t n); +- +-_gsl_vector_short_const_view +-gsl_vector_short_const_subvector_with_stride (const gsl_vector_short *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_short_set_zero (gsl_vector_short * v); +-void gsl_vector_short_set_all (gsl_vector_short * v, short x); +-int gsl_vector_short_set_basis (gsl_vector_short * v, size_t i); +- +-int gsl_vector_short_fread (FILE * stream, gsl_vector_short * v); +-int gsl_vector_short_fwrite (FILE * stream, const gsl_vector_short * v); +-int gsl_vector_short_fscanf (FILE * stream, gsl_vector_short * v); +-int gsl_vector_short_fprintf (FILE * stream, const gsl_vector_short * v, +- const char *format); +- +-int gsl_vector_short_memcpy (gsl_vector_short * dest, const gsl_vector_short * src); +- +-int gsl_vector_short_reverse (gsl_vector_short * v); +- +-int gsl_vector_short_swap (gsl_vector_short * v, gsl_vector_short * w); +-int gsl_vector_short_swap_elements (gsl_vector_short * v, const size_t i, const size_t j); +- +-short gsl_vector_short_max (const gsl_vector_short * v); +-short gsl_vector_short_min (const gsl_vector_short * v); +-void gsl_vector_short_minmax (const gsl_vector_short * v, short * min_out, short * max_out); +- +-size_t gsl_vector_short_max_index (const gsl_vector_short * v); +-size_t gsl_vector_short_min_index (const gsl_vector_short * v); +-void gsl_vector_short_minmax_index (const gsl_vector_short * v, size_t * imin, size_t * imax); +- +-int gsl_vector_short_add (gsl_vector_short * a, const gsl_vector_short * b); +-int gsl_vector_short_sub (gsl_vector_short * a, const gsl_vector_short * b); +-int gsl_vector_short_mul (gsl_vector_short * a, const gsl_vector_short * b); +-int gsl_vector_short_div (gsl_vector_short * a, const gsl_vector_short * b); +-int gsl_vector_short_scale (gsl_vector_short * a, const double x); +-int gsl_vector_short_add_constant (gsl_vector_short * a, const double x); +- +-int gsl_vector_short_equal (const gsl_vector_short * u, +- const gsl_vector_short * v); +- +-int gsl_vector_short_isnull (const gsl_vector_short * v); +-int gsl_vector_short_ispos (const gsl_vector_short * v); +-int gsl_vector_short_isneg (const gsl_vector_short * v); +-int gsl_vector_short_isnonneg (const gsl_vector_short * v); +- +-INLINE_DECL short gsl_vector_short_get (const gsl_vector_short * v, const size_t i); +-INLINE_DECL void gsl_vector_short_set (gsl_vector_short * v, const size_t i, short x); +-INLINE_DECL short * gsl_vector_short_ptr (gsl_vector_short * v, const size_t i); +-INLINE_DECL const short * gsl_vector_short_const_ptr (const gsl_vector_short * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-short +-gsl_vector_short_get (const gsl_vector_short * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_short_set (gsl_vector_short * v, const size_t i, short x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-short * +-gsl_vector_short_ptr (gsl_vector_short * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (short *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const short * +-gsl_vector_short_const_ptr (const gsl_vector_short * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const short *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_SHORT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas.h (revision 14079) +@@ -1,602 +0,0 @@ +-/* blas/gsl_blas.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* +- * Author: G. Jungman +- */ +-#ifndef __GSL_BLAS_H__ +-#define __GSL_BLAS_H__ +- +-#include +-#include +- +-#include +- +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* ======================================================================== +- * Level 1 +- * ======================================================================== +- */ +- +-int gsl_blas_sdsdot (float alpha, +- const gsl_vector_float * X, +- const gsl_vector_float * Y, +- float * result +- ); +- +-int gsl_blas_dsdot (const gsl_vector_float * X, +- const gsl_vector_float * Y, +- double * result +- ); +- +-int gsl_blas_sdot (const gsl_vector_float * X, +- const gsl_vector_float * Y, +- float * result +- ); +- +-int gsl_blas_ddot (const gsl_vector * X, +- const gsl_vector * Y, +- double * result +- ); +- +- +-int gsl_blas_cdotu (const gsl_vector_complex_float * X, +- const gsl_vector_complex_float * Y, +- gsl_complex_float * dotu); +- +-int gsl_blas_cdotc (const gsl_vector_complex_float * X, +- const gsl_vector_complex_float * Y, +- gsl_complex_float * dotc); +- +-int gsl_blas_zdotu (const gsl_vector_complex * X, +- const gsl_vector_complex * Y, +- gsl_complex * dotu); +- +-int gsl_blas_zdotc (const gsl_vector_complex * X, +- const gsl_vector_complex * Y, +- gsl_complex * dotc); +- +- +-float gsl_blas_snrm2 (const gsl_vector_float * X); +-float gsl_blas_sasum (const gsl_vector_float * X); +-double gsl_blas_dnrm2 (const gsl_vector * X); +-double gsl_blas_dasum (const gsl_vector * X); +-float gsl_blas_scnrm2 (const gsl_vector_complex_float * X); +-float gsl_blas_scasum (const gsl_vector_complex_float * X); +-double gsl_blas_dznrm2 (const gsl_vector_complex * X); +-double gsl_blas_dzasum (const gsl_vector_complex * X); +- +- +-CBLAS_INDEX_t gsl_blas_isamax (const gsl_vector_float * X); +-CBLAS_INDEX_t gsl_blas_idamax (const gsl_vector * X); +-CBLAS_INDEX_t gsl_blas_icamax (const gsl_vector_complex_float * X); +-CBLAS_INDEX_t gsl_blas_izamax (const gsl_vector_complex * X); +- +- +-int gsl_blas_sswap (gsl_vector_float * X, +- gsl_vector_float * Y); +- +-int gsl_blas_scopy (const gsl_vector_float * X, +- gsl_vector_float * Y); +- +-int gsl_blas_saxpy (float alpha, +- const gsl_vector_float * X, +- gsl_vector_float * Y); +- +-int gsl_blas_dswap (gsl_vector * X, +- gsl_vector * Y); +- +-int gsl_blas_dcopy (const gsl_vector * X, +- gsl_vector * Y); +- +-int gsl_blas_daxpy (double alpha, +- const gsl_vector * X, +- gsl_vector * Y); +- +-int gsl_blas_cswap (gsl_vector_complex_float * X, +- gsl_vector_complex_float * Y); +- +-int gsl_blas_ccopy (const gsl_vector_complex_float * X, +- gsl_vector_complex_float * Y); +- +-int gsl_blas_caxpy (const gsl_complex_float alpha, +- const gsl_vector_complex_float * X, +- gsl_vector_complex_float * Y); +- +-int gsl_blas_zswap (gsl_vector_complex * X, +- gsl_vector_complex * Y); +- +-int gsl_blas_zcopy (const gsl_vector_complex * X, +- gsl_vector_complex * Y); +- +-int gsl_blas_zaxpy (const gsl_complex alpha, +- const gsl_vector_complex * X, +- gsl_vector_complex * Y); +- +- +-int gsl_blas_srotg (float a[], float b[], float c[], float s[]); +- +-int gsl_blas_srotmg (float d1[], float d2[], float b1[], float b2, float P[]); +- +-int gsl_blas_srot (gsl_vector_float * X, +- gsl_vector_float * Y, +- float c, float s); +- +-int gsl_blas_srotm (gsl_vector_float * X, +- gsl_vector_float * Y, +- const float P[]); +- +-int gsl_blas_drotg (double a[], double b[], double c[], double s[]); +- +-int gsl_blas_drotmg (double d1[], double d2[], double b1[], +- double b2, double P[]); +- +-int gsl_blas_drot (gsl_vector * X, +- gsl_vector * Y, +- const double c, const double s); +- +-int gsl_blas_drotm (gsl_vector * X, +- gsl_vector * Y, +- const double P[]); +- +- +-void gsl_blas_sscal (float alpha, gsl_vector_float * X); +-void gsl_blas_dscal (double alpha, gsl_vector * X); +-void gsl_blas_cscal (const gsl_complex_float alpha, gsl_vector_complex_float * X); +-void gsl_blas_zscal (const gsl_complex alpha, gsl_vector_complex * X); +-void gsl_blas_csscal (float alpha, gsl_vector_complex_float * X); +-void gsl_blas_zdscal (double alpha, gsl_vector_complex * X); +- +- +-/* =========================================================================== +- * Level 2 +- * =========================================================================== +- */ +- +-/* +- * Routines with standard 4 prefixes (S, D, C, Z) +- */ +-int gsl_blas_sgemv (CBLAS_TRANSPOSE_t TransA, +- float alpha, +- const gsl_matrix_float * A, +- const gsl_vector_float * X, +- float beta, +- gsl_vector_float * Y); +- +-int gsl_blas_strmv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_float * A, +- gsl_vector_float * X); +- +-int gsl_blas_strsv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_float * A, +- gsl_vector_float * X); +- +-int gsl_blas_dgemv (CBLAS_TRANSPOSE_t TransA, +- double alpha, +- const gsl_matrix * A, +- const gsl_vector * X, +- double beta, +- gsl_vector * Y); +- +-int gsl_blas_dtrmv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix * A, +- gsl_vector * X); +- +-int gsl_blas_dtrsv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix * A, +- gsl_vector * X); +- +-int gsl_blas_cgemv (CBLAS_TRANSPOSE_t TransA, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_vector_complex_float * X, +- const gsl_complex_float beta, +- gsl_vector_complex_float * Y); +- +-int gsl_blas_ctrmv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_complex_float * A, +- gsl_vector_complex_float * X); +- +-int gsl_blas_ctrsv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_complex_float * A, +- gsl_vector_complex_float * X); +- +-int gsl_blas_zgemv (CBLAS_TRANSPOSE_t TransA, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_vector_complex * X, +- const gsl_complex beta, +- gsl_vector_complex * Y); +- +-int gsl_blas_ztrmv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_complex * A, +- gsl_vector_complex * X); +- +-int gsl_blas_ztrsv (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, +- const gsl_matrix_complex * A, +- gsl_vector_complex *X); +- +-/* +- * Routines with S and D prefixes only +- */ +-int gsl_blas_ssymv (CBLAS_UPLO_t Uplo, +- float alpha, +- const gsl_matrix_float * A, +- const gsl_vector_float * X, +- float beta, +- gsl_vector_float * Y); +- +-int gsl_blas_sger (float alpha, +- const gsl_vector_float * X, +- const gsl_vector_float * Y, +- gsl_matrix_float * A); +- +-int gsl_blas_ssyr (CBLAS_UPLO_t Uplo, +- float alpha, +- const gsl_vector_float * X, +- gsl_matrix_float * A); +- +-int gsl_blas_ssyr2 (CBLAS_UPLO_t Uplo, +- float alpha, +- const gsl_vector_float * X, +- const gsl_vector_float * Y, +- gsl_matrix_float * A); +- +-int gsl_blas_dsymv (CBLAS_UPLO_t Uplo, +- double alpha, +- const gsl_matrix * A, +- const gsl_vector * X, +- double beta, +- gsl_vector * Y); +-int gsl_blas_dger (double alpha, +- const gsl_vector * X, +- const gsl_vector * Y, +- gsl_matrix * A); +- +-int gsl_blas_dsyr (CBLAS_UPLO_t Uplo, +- double alpha, +- const gsl_vector * X, +- gsl_matrix * A); +- +-int gsl_blas_dsyr2 (CBLAS_UPLO_t Uplo, +- double alpha, +- const gsl_vector * X, +- const gsl_vector * Y, +- gsl_matrix * A); +- +-/* +- * Routines with C and Z prefixes only +- */ +- +-int gsl_blas_chemv (CBLAS_UPLO_t Uplo, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_vector_complex_float * X, +- const gsl_complex_float beta, +- gsl_vector_complex_float * Y); +- +-int gsl_blas_cgeru (const gsl_complex_float alpha, +- const gsl_vector_complex_float * X, +- const gsl_vector_complex_float * Y, +- gsl_matrix_complex_float * A); +- +-int gsl_blas_cgerc (const gsl_complex_float alpha, +- const gsl_vector_complex_float * X, +- const gsl_vector_complex_float * Y, +- gsl_matrix_complex_float * A); +- +-int gsl_blas_cher (CBLAS_UPLO_t Uplo, +- float alpha, +- const gsl_vector_complex_float * X, +- gsl_matrix_complex_float * A); +- +-int gsl_blas_cher2 (CBLAS_UPLO_t Uplo, +- const gsl_complex_float alpha, +- const gsl_vector_complex_float * X, +- const gsl_vector_complex_float * Y, +- gsl_matrix_complex_float * A); +- +-int gsl_blas_zhemv (CBLAS_UPLO_t Uplo, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_vector_complex * X, +- const gsl_complex beta, +- gsl_vector_complex * Y); +- +-int gsl_blas_zgeru (const gsl_complex alpha, +- const gsl_vector_complex * X, +- const gsl_vector_complex * Y, +- gsl_matrix_complex * A); +- +-int gsl_blas_zgerc (const gsl_complex alpha, +- const gsl_vector_complex * X, +- const gsl_vector_complex * Y, +- gsl_matrix_complex * A); +- +-int gsl_blas_zher (CBLAS_UPLO_t Uplo, +- double alpha, +- const gsl_vector_complex * X, +- gsl_matrix_complex * A); +- +-int gsl_blas_zher2 (CBLAS_UPLO_t Uplo, +- const gsl_complex alpha, +- const gsl_vector_complex * X, +- const gsl_vector_complex * Y, +- gsl_matrix_complex * A); +- +-/* +- * =========================================================================== +- * Prototypes for level 3 BLAS +- * =========================================================================== +- */ +- +-/* +- * Routines with standard 4 prefixes (S, D, C, Z) +- */ +-int gsl_blas_sgemm (CBLAS_TRANSPOSE_t TransA, +- CBLAS_TRANSPOSE_t TransB, +- float alpha, +- const gsl_matrix_float * A, +- const gsl_matrix_float * B, +- float beta, +- gsl_matrix_float * C); +- +-int gsl_blas_ssymm (CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, +- float alpha, +- const gsl_matrix_float * A, +- const gsl_matrix_float * B, +- float beta, +- gsl_matrix_float * C); +- +-int gsl_blas_ssyrk (CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, +- float alpha, +- const gsl_matrix_float * A, +- float beta, +- gsl_matrix_float * C); +- +-int gsl_blas_ssyr2k (CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, +- float alpha, +- const gsl_matrix_float * A, +- const gsl_matrix_float * B, +- float beta, +- gsl_matrix_float * C); +- +-int gsl_blas_strmm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- float alpha, +- const gsl_matrix_float * A, +- gsl_matrix_float * B); +- +-int gsl_blas_strsm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- float alpha, +- const gsl_matrix_float * A, +- gsl_matrix_float * B); +- +-int gsl_blas_dgemm (CBLAS_TRANSPOSE_t TransA, +- CBLAS_TRANSPOSE_t TransB, +- double alpha, +- const gsl_matrix * A, +- const gsl_matrix * B, +- double beta, +- gsl_matrix * C); +- +-int gsl_blas_dsymm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, +- double alpha, +- const gsl_matrix * A, +- const gsl_matrix * B, +- double beta, +- gsl_matrix * C); +- +-int gsl_blas_dsyrk (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- double alpha, +- const gsl_matrix * A, +- double beta, +- gsl_matrix * C); +- +-int gsl_blas_dsyr2k (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- double alpha, +- const gsl_matrix * A, +- const gsl_matrix * B, +- double beta, +- gsl_matrix * C); +- +-int gsl_blas_dtrmm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- double alpha, +- const gsl_matrix * A, +- gsl_matrix * B); +- +-int gsl_blas_dtrsm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- double alpha, +- const gsl_matrix * A, +- gsl_matrix * B); +- +-int gsl_blas_cgemm (CBLAS_TRANSPOSE_t TransA, +- CBLAS_TRANSPOSE_t TransB, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_matrix_complex_float * B, +- const gsl_complex_float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_csymm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_matrix_complex_float * B, +- const gsl_complex_float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_csyrk (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_complex_float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_csyr2k (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_matrix_complex_float * B, +- const gsl_complex_float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_ctrmm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- gsl_matrix_complex_float * B); +- +-int gsl_blas_ctrsm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- gsl_matrix_complex_float * B); +- +-int gsl_blas_zgemm (CBLAS_TRANSPOSE_t TransA, +- CBLAS_TRANSPOSE_t TransB, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_matrix_complex * B, +- const gsl_complex beta, +- gsl_matrix_complex * C); +- +-int gsl_blas_zsymm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_matrix_complex * B, +- const gsl_complex beta, +- gsl_matrix_complex * C); +- +-int gsl_blas_zsyrk (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_complex beta, +- gsl_matrix_complex * C); +- +-int gsl_blas_zsyr2k (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_matrix_complex * B, +- const gsl_complex beta, +- gsl_matrix_complex *C); +- +-int gsl_blas_ztrmm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- gsl_matrix_complex * B); +- +-int gsl_blas_ztrsm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, +- CBLAS_DIAG_t Diag, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- gsl_matrix_complex * B); +- +-/* +- * Routines with prefixes C and Z only +- */ +-int gsl_blas_chemm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_matrix_complex_float * B, +- const gsl_complex_float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_cherk (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- float alpha, +- const gsl_matrix_complex_float * A, +- float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_cher2k (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex_float alpha, +- const gsl_matrix_complex_float * A, +- const gsl_matrix_complex_float * B, +- float beta, +- gsl_matrix_complex_float * C); +- +-int gsl_blas_zhemm (CBLAS_SIDE_t Side, +- CBLAS_UPLO_t Uplo, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_matrix_complex * B, +- const gsl_complex beta, +- gsl_matrix_complex * C); +- +-int gsl_blas_zherk (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- double alpha, +- const gsl_matrix_complex * A, +- double beta, +- gsl_matrix_complex * C); +- +-int gsl_blas_zher2k (CBLAS_UPLO_t Uplo, +- CBLAS_TRANSPOSE_t Trans, +- const gsl_complex alpha, +- const gsl_matrix_complex * A, +- const gsl_matrix_complex * B, +- double beta, +- gsl_matrix_complex * C); +- +- +-__END_DECLS +- +-#endif /* __GSL_BLAS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_long_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_complex_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ +-#define __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_complex_long_double (const size_t * p, long double * data, const size_t stride, const size_t n); +-int gsl_permute_complex_long_double_inverse (const size_t * p, long double * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fit.h (revision 14079) +@@ -1,85 +0,0 @@ +-/* fit/gsl_fit.h +- * +- * Copyright (C) 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FIT_H__ +-#define __GSL_FIT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_fit_linear (const double * x, const size_t xstride, +- const double * y, const size_t ystride, +- const size_t n, +- double * c0, double * c1, +- double * cov00, double * cov01, double * cov11, +- double * sumsq); +- +- +-int gsl_fit_wlinear (const double * x, const size_t xstride, +- const double * w, const size_t wstride, +- const double * y, const size_t ystride, +- const size_t n, +- double * c0, double * c1, +- double * cov00, double * cov01, double * cov11, +- double * chisq); +- +-int +-gsl_fit_linear_est (const double x, +- const double c0, const double c1, +- const double cov00, const double cov01, const double cov11, +- double *y, double *y_err); +- +- +-int gsl_fit_mul (const double * x, const size_t xstride, +- const double * y, const size_t ystride, +- const size_t n, +- double * c1, +- double * cov11, +- double * sumsq); +- +-int gsl_fit_wmul (const double * x, const size_t xstride, +- const double * w, const size_t wstride, +- const double * y, const size_t ystride, +- const size_t n, +- double * c1, +- double * cov11, +- double * sumsq); +- +- +-int +-gsl_fit_mul_est (const double x, +- const double c1, +- const double cov11, +- double *y, double *y_err); +- +-__END_DECLS +- +-#endif /* __GSL_FIT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_poly.h (revision 14079) +@@ -1,179 +0,0 @@ +-/* poly/gsl_poly.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_POLY_H__ +-#define __GSL_POLY_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Evaluate polynomial +- * +- * c[0] + c[1] x + c[2] x^2 + ... + c[len-1] x^(len-1) +- * +- * exceptions: none +- */ +- +-/* real polynomial, real x */ +-INLINE_DECL double gsl_poly_eval(const double c[], const int len, const double x); +- +-/* real polynomial, complex x */ +-INLINE_DECL gsl_complex gsl_poly_complex_eval (const double c [], const int len, const gsl_complex z); +- +-/* complex polynomial, complex x */ +-INLINE_DECL gsl_complex gsl_complex_poly_complex_eval (const gsl_complex c [], const int len, const gsl_complex z); +- +-int gsl_poly_eval_derivs(const double c[], const size_t lenc, const double x, double res[], const size_t lenres); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-double +-gsl_poly_eval(const double c[], const int len, const double x) +-{ +- int i; +- double ans = c[len-1]; +- for(i=len-1; i>0; i--) ans = c[i-1] + x * ans; +- return ans; +-} +- +-INLINE_FUN +-gsl_complex +-gsl_poly_complex_eval(const double c[], const int len, const gsl_complex z) +-{ +- int i; +- gsl_complex ans; +- GSL_SET_COMPLEX (&ans, c[len-1], 0.0); +- for(i=len-1; i>0; i--) { +- /* The following three lines are equivalent to +- ans = gsl_complex_add_real (gsl_complex_mul (z, ans), c[i-1]); +- but faster */ +- double tmp = c[i-1] + GSL_REAL (z) * GSL_REAL (ans) - GSL_IMAG (z) * GSL_IMAG (ans); +- GSL_SET_IMAG (&ans, GSL_IMAG (z) * GSL_REAL (ans) + GSL_REAL (z) * GSL_IMAG (ans)); +- GSL_SET_REAL (&ans, tmp); +- } +- return ans; +-} +- +-INLINE_FUN +-gsl_complex +-gsl_complex_poly_complex_eval(const gsl_complex c[], const int len, const gsl_complex z) +-{ +- int i; +- gsl_complex ans = c[len-1]; +- for(i=len-1; i>0; i--) { +- /* The following three lines are equivalent to +- ans = gsl_complex_add (c[i-1], gsl_complex_mul (x, ans)); +- but faster */ +- double tmp = GSL_REAL (c[i-1]) + GSL_REAL (z) * GSL_REAL (ans) - GSL_IMAG (z) * GSL_IMAG (ans); +- GSL_SET_IMAG (&ans, GSL_IMAG (c[i-1]) + GSL_IMAG (z) * GSL_REAL (ans) + GSL_REAL (z) * GSL_IMAG (ans)); +- GSL_SET_REAL (&ans, tmp); +- } +- return ans; +-} +-#endif /* HAVE_INLINE */ +- +-/* Work with divided-difference polynomials, Abramowitz & Stegun 25.2.26 */ +- +-int +-gsl_poly_dd_init (double dd[], const double x[], const double y[], +- size_t size); +- +-INLINE_DECL double +-gsl_poly_dd_eval (const double dd[], const double xa[], const size_t size, const double x); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-double +-gsl_poly_dd_eval(const double dd[], const double xa[], const size_t size, const double x) +-{ +- size_t i; +- double y = dd[size - 1]; +- for (i = size - 1; i--;) y = dd[i] + (x - xa[i]) * y; +- return y; +-} +-#endif /* HAVE_INLINE */ +- +- +-int +-gsl_poly_dd_taylor (double c[], double xp, +- const double dd[], const double x[], size_t size, +- double w[]); +- +-/* Solve for real or complex roots of the standard quadratic equation, +- * returning the number of real roots. +- * +- * Roots are returned ordered. +- */ +-int gsl_poly_solve_quadratic (double a, double b, double c, +- double * x0, double * x1); +- +-int +-gsl_poly_complex_solve_quadratic (double a, double b, double c, +- gsl_complex * z0, gsl_complex * z1); +- +- +-/* Solve for real roots of the cubic equation +- * x^3 + a x^2 + b x + c = 0, returning the +- * number of real roots. +- * +- * Roots are returned ordered. +- */ +-int gsl_poly_solve_cubic (double a, double b, double c, +- double * x0, double * x1, double * x2); +- +-int +-gsl_poly_complex_solve_cubic (double a, double b, double c, +- gsl_complex * z0, gsl_complex * z1, +- gsl_complex * z2); +- +- +-/* Solve for the complex roots of a general real polynomial */ +- +-typedef struct +-{ +- size_t nc ; +- double * matrix ; +-} +-gsl_poly_complex_workspace ; +- +-gsl_poly_complex_workspace * gsl_poly_complex_workspace_alloc (size_t n); +-void gsl_poly_complex_workspace_free (gsl_poly_complex_workspace * w); +- +-int +-gsl_poly_complex_solve (const double * a, size_t n, +- gsl_poly_complex_workspace * w, +- gsl_complex_packed_ptr z); +- +-__END_DECLS +- +-#endif /* __GSL_POLY_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_integration.h (revision 14079) +@@ -1,323 +0,0 @@ +-/* integration/gsl_integration.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_INTEGRATION_H__ +-#define __GSL_INTEGRATION_H__ +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Workspace for adaptive integrators */ +- +-typedef struct +- { +- size_t limit; +- size_t size; +- size_t nrmax; +- size_t i; +- size_t maximum_level; +- double *alist; +- double *blist; +- double *rlist; +- double *elist; +- size_t *order; +- size_t *level; +- } +-gsl_integration_workspace; +- +-gsl_integration_workspace * +- gsl_integration_workspace_alloc (const size_t n); +- +-void +- gsl_integration_workspace_free (gsl_integration_workspace * w); +- +- +-/* Workspace for QAWS integrator */ +- +-typedef struct +-{ +- double alpha; +- double beta; +- int mu; +- int nu; +- double ri[25]; +- double rj[25]; +- double rg[25]; +- double rh[25]; +-} +-gsl_integration_qaws_table; +- +-gsl_integration_qaws_table * +-gsl_integration_qaws_table_alloc (double alpha, double beta, int mu, int nu); +- +-int +-gsl_integration_qaws_table_set (gsl_integration_qaws_table * t, +- double alpha, double beta, int mu, int nu); +- +-void +-gsl_integration_qaws_table_free (gsl_integration_qaws_table * t); +- +-/* Workspace for QAWO integrator */ +- +-enum gsl_integration_qawo_enum { GSL_INTEG_COSINE, GSL_INTEG_SINE }; +- +-typedef struct +-{ +- size_t n; +- double omega; +- double L; +- double par; +- enum gsl_integration_qawo_enum sine; +- double *chebmo; +-} +-gsl_integration_qawo_table; +- +-gsl_integration_qawo_table * +-gsl_integration_qawo_table_alloc (double omega, double L, +- enum gsl_integration_qawo_enum sine, +- size_t n); +- +-int +-gsl_integration_qawo_table_set (gsl_integration_qawo_table * t, +- double omega, double L, +- enum gsl_integration_qawo_enum sine); +- +-int +-gsl_integration_qawo_table_set_length (gsl_integration_qawo_table * t, +- double L); +- +-void +-gsl_integration_qawo_table_free (gsl_integration_qawo_table * t); +- +- +-/* Definition of an integration rule */ +- +-typedef void gsl_integration_rule (const gsl_function * f, +- double a, double b, +- double *result, double *abserr, +- double *defabs, double *resabs); +- +-void gsl_integration_qk15 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qk21 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qk31 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qk41 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qk51 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qk61 (const gsl_function * f, double a, double b, +- double *result, double *abserr, +- double *resabs, double *resasc); +- +-void gsl_integration_qcheb (gsl_function * f, double a, double b, +- double *cheb12, double *cheb24); +- +-/* The low-level integration rules in QUADPACK are identified by small +- integers (1-6). We'll use symbolic constants to refer to them. */ +- +-enum +- { +- GSL_INTEG_GAUSS15 = 1, /* 15 point Gauss-Kronrod rule */ +- GSL_INTEG_GAUSS21 = 2, /* 21 point Gauss-Kronrod rule */ +- GSL_INTEG_GAUSS31 = 3, /* 31 point Gauss-Kronrod rule */ +- GSL_INTEG_GAUSS41 = 4, /* 41 point Gauss-Kronrod rule */ +- GSL_INTEG_GAUSS51 = 5, /* 51 point Gauss-Kronrod rule */ +- GSL_INTEG_GAUSS61 = 6 /* 61 point Gauss-Kronrod rule */ +- }; +- +-void +-gsl_integration_qk (const int n, const double xgk[], +- const double wg[], const double wgk[], +- double fv1[], double fv2[], +- const gsl_function *f, double a, double b, +- double * result, double * abserr, +- double * resabs, double * resasc); +- +- +-int gsl_integration_qng (const gsl_function * f, +- double a, double b, +- double epsabs, double epsrel, +- double *result, double *abserr, +- size_t * neval); +- +-int gsl_integration_qag (const gsl_function * f, +- double a, double b, +- double epsabs, double epsrel, size_t limit, +- int key, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qagi (gsl_function * f, +- double epsabs, double epsrel, size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qagiu (gsl_function * f, +- double a, +- double epsabs, double epsrel, size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qagil (gsl_function * f, +- double b, +- double epsabs, double epsrel, size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +- +-int gsl_integration_qags (const gsl_function * f, +- double a, double b, +- double epsabs, double epsrel, size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qagp (const gsl_function * f, +- double *pts, size_t npts, +- double epsabs, double epsrel, size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qawc (gsl_function *f, +- const double a, const double b, const double c, +- const double epsabs, const double epsrel, const size_t limit, +- gsl_integration_workspace * workspace, +- double * result, double * abserr); +- +-int gsl_integration_qaws (gsl_function * f, +- const double a, const double b, +- gsl_integration_qaws_table * t, +- const double epsabs, const double epsrel, +- const size_t limit, +- gsl_integration_workspace * workspace, +- double *result, double *abserr); +- +-int gsl_integration_qawo (gsl_function * f, +- const double a, +- const double epsabs, const double epsrel, +- const size_t limit, +- gsl_integration_workspace * workspace, +- gsl_integration_qawo_table * wf, +- double *result, double *abserr); +- +-int gsl_integration_qawf (gsl_function * f, +- const double a, +- const double epsabs, +- const size_t limit, +- gsl_integration_workspace * workspace, +- gsl_integration_workspace * cycle_workspace, +- gsl_integration_qawo_table * wf, +- double *result, double *abserr); +- +-/* Workspace for fixed-order Gauss-Legendre integration */ +- +-typedef struct +- { +- size_t n; /* number of points */ +- double *x; /* Gauss abscissae/points */ +- double *w; /* Gauss weights for each abscissae */ +- int precomputed; /* high precision abscissae/weights precomputed? */ +- } +-gsl_integration_glfixed_table; +- +- +-gsl_integration_glfixed_table * +- gsl_integration_glfixed_table_alloc (size_t n); +- +-void +- gsl_integration_glfixed_table_free (gsl_integration_glfixed_table * t); +- +-/* Routine for fixed-order Gauss-Legendre integration */ +- +-double +- gsl_integration_glfixed (const gsl_function *f, +- double a, +- double b, +- const gsl_integration_glfixed_table * t); +- +-/* Routine to retrieve the i-th Gauss-Legendre point and weight from t */ +- +-int +- gsl_integration_glfixed_point (double a, +- double b, +- size_t i, +- double *xi, +- double *wi, +- const gsl_integration_glfixed_table * t); +- +- +-/* Cquad integration - Pedro Gonnet */ +- +-/* Data of a single interval */ +-typedef struct +-{ +- double a, b; +- double c[64]; +- double fx[33]; +- double igral, err; +- int depth, rdepth, ndiv; +-} gsl_integration_cquad_ival; +- +- +-/* The workspace is just a collection of intervals */ +-typedef struct +-{ +- size_t size; +- gsl_integration_cquad_ival *ivals; +- size_t *heap; +-} gsl_integration_cquad_workspace; +- +-gsl_integration_cquad_workspace * +-gsl_integration_cquad_workspace_alloc (const size_t n); +- +-void +-gsl_integration_cquad_workspace_free (gsl_integration_cquad_workspace * w); +- +-int +-gsl_integration_cquad (const gsl_function * f, double a, double b, +- double epsabs, double epsrel, +- gsl_integration_cquad_workspace * ws, +- double *result, double *abserr, size_t * nevals); +- +- +-__END_DECLS +- +-#endif /* __GSL_INTEGRATION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_min.h (revision 14079) +@@ -1,111 +0,0 @@ +-/* min/gsl_min.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MIN_H__ +-#define __GSL_MIN_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*set) (void *state, gsl_function * f, double x_minimum, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper); +- int (*iterate) (void *state, gsl_function * f, double * x_minimum, double * f_minimum, double * x_lower, double * f_lower, double * x_upper, double * f_upper); +- } +-gsl_min_fminimizer_type; +- +-typedef struct +- { +- const gsl_min_fminimizer_type * type; +- gsl_function * function ; +- double x_minimum ; +- double x_lower ; +- double x_upper ; +- double f_minimum, f_lower, f_upper; +- void *state; +- } +-gsl_min_fminimizer; +- +-gsl_min_fminimizer * +-gsl_min_fminimizer_alloc (const gsl_min_fminimizer_type * T) ; +- +-void gsl_min_fminimizer_free (gsl_min_fminimizer * s); +- +-int gsl_min_fminimizer_set (gsl_min_fminimizer * s, +- gsl_function * f, double x_minimum, +- double x_lower, double x_upper); +- +-int gsl_min_fminimizer_set_with_values (gsl_min_fminimizer * s, +- gsl_function * f, +- double x_minimum, double f_minimum, +- double x_lower, double f_lower, +- double x_upper, double f_upper); +- +-int gsl_min_fminimizer_iterate (gsl_min_fminimizer * s); +- +-const char * gsl_min_fminimizer_name (const gsl_min_fminimizer * s); +- +-double gsl_min_fminimizer_x_minimum (const gsl_min_fminimizer * s); +-double gsl_min_fminimizer_x_lower (const gsl_min_fminimizer * s); +-double gsl_min_fminimizer_x_upper (const gsl_min_fminimizer * s); +-double gsl_min_fminimizer_f_minimum (const gsl_min_fminimizer * s); +-double gsl_min_fminimizer_f_lower (const gsl_min_fminimizer * s); +-double gsl_min_fminimizer_f_upper (const gsl_min_fminimizer * s); +- +-/* Deprecated, use x_minimum instead */ +-double gsl_min_fminimizer_minimum (const gsl_min_fminimizer * s); +- +-int +-gsl_min_test_interval (double x_lower, double x_upper, double epsabs, double epsrel); +- +-GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_goldensection; +-GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_brent; +-GSL_VAR const gsl_min_fminimizer_type * gsl_min_fminimizer_quad_golden; +- +-typedef +-int (*gsl_min_bracketing_function)(gsl_function *f, +- double *x_minimum,double * f_minimum, +- double *x_lower, double * f_lower, +- double *x_upper, double * f_upper, +- size_t eval_max); +- +-int +-gsl_min_find_bracket(gsl_function *f,double *x_minimum,double * f_minimum, +- double *x_lower, double * f_lower, +- double *x_upper, double * f_upper, +- size_t eval_max); +- +-__END_DECLS +- +-#endif /* __GSL_MIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_mode.h (revision 14079) +@@ -1,88 +0,0 @@ +-/* gsl_mode.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: B. Gough and G. Jungman */ +- +-#ifndef __GSL_MODE_H__ +-#define __GSL_MODE_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Some functions can take a mode argument. This +- * is a rough method to do things like control +- * the precision of the algorithm. This mainly +- * occurs in special functions, but we figured +- * it was ok to have a general facility. +- * +- * The mode type is 32-bit field. Most of +- * the fields are currently unused. Users +- * '|' various predefined constants to get +- * a desired mode. +- */ +-typedef unsigned int gsl_mode_t; +- +- +-/* Here are the predefined constants. +- * Note that the precision constants +- * are special because they are used +- * to index arrays, so do not change +- * them. The precision information is +- * in the low order 3 bits of gsl_mode_t +- * (the third bit is currently unused). +- */ +- +-/* Note that "0" is double precision, +- * so that you get that by default if +- * you forget a flag. +- */ +-#define GSL_PREC_DOUBLE 0 +-#define GSL_PREC_SINGLE 1 +-#define GSL_PREC_APPROX 2 +- +-#ifdef HAVE_INLINE +-INLINE_FUN unsigned int GSL_MODE_PREC(gsl_mode_t mt); +- +-INLINE_FUN unsigned int +-GSL_MODE_PREC(gsl_mode_t mt) +-{ return (mt & (unsigned int)7); } +-#else /* HAVE_INLINE */ +-#define GSL_MODE_PREC(mt) ((mt) & (unsigned int)7) +-#endif /* HAVE_INLINE */ +- +- +-/* Here are some predefined generic modes. +- */ +-#define GSL_MODE_DEFAULT 0 +- +- +-__END_DECLS +- +-#endif /* __GSL_MODE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_char.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_CHAR_H__ +-#define __GSL_SORT_CHAR_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_char (char * data, const size_t stride, const size_t n); +-void gsl_sort_char_index (size_t * p, const char * data, const size_t stride, const size_t n); +- +-int gsl_sort_char_smallest (char * dest, const size_t k, const char * src, const size_t stride, const size_t n); +-int gsl_sort_char_smallest_index (size_t * p, const size_t k, const char * src, const size_t stride, const size_t n); +- +-int gsl_sort_char_largest (char * dest, const size_t k, const char * src, const size_t stride, const size_t n); +-int gsl_sort_char_largest_index (size_t * p, const size_t k, const char * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uchar.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_UCHAR_H__ +-#define __GSL_PERMUTE_VECTOR_UCHAR_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_uchar (const gsl_permutation * p, gsl_vector_uchar * v); +-int gsl_permute_vector_uchar_inverse (const gsl_permutation * p, gsl_vector_uchar * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_char.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_CHAR_H__ +-#define __GSL_BLOCK_CHAR_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_char_struct +-{ +- size_t size; +- char *data; +-}; +- +-typedef struct gsl_block_char_struct gsl_block_char; +- +-gsl_block_char *gsl_block_char_alloc (const size_t n); +-gsl_block_char *gsl_block_char_calloc (const size_t n); +-void gsl_block_char_free (gsl_block_char * b); +- +-int gsl_block_char_fread (FILE * stream, gsl_block_char * b); +-int gsl_block_char_fwrite (FILE * stream, const gsl_block_char * b); +-int gsl_block_char_fscanf (FILE * stream, gsl_block_char * b); +-int gsl_block_char_fprintf (FILE * stream, const gsl_block_char * b, const char *format); +- +-int gsl_block_char_raw_fread (FILE * stream, char * b, const size_t n, const size_t stride); +-int gsl_block_char_raw_fwrite (FILE * stream, const char * b, const size_t n, const size_t stride); +-int gsl_block_char_raw_fscanf (FILE * stream, char * b, const size_t n, const size_t stride); +-int gsl_block_char_raw_fprintf (FILE * stream, const char * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_char_size (const gsl_block_char * b); +-char * gsl_block_char_data (const gsl_block_char * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_odeiv2.h (revision 14079) +@@ -1,332 +0,0 @@ +-/* ode-initval/odeiv2.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +-/* Modified by Tuomo Keskitalo */ +- +-#ifndef __GSL_ODEIV2_H__ +-#define __GSL_ODEIV2_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +-/* Description of a system of ODEs. +- * +- * y' = f(t,y) = dydt(t, y) +- * +- * The system is specified by giving the right-hand-side +- * of the equation and possibly a jacobian function. +- * +- * Some methods require the jacobian function, which calculates +- * the matrix dfdy and the vector dfdt. The matrix dfdy conforms +- * to the GSL standard, being a continuous range of floating point +- * values, in row-order. +- * +- * As with GSL function objects, user-supplied parameter +- * data is also present. +- */ +- typedef struct +-{ +- int (*function) (double t, const double y[], double dydt[], void *params); +- int (*jacobian) (double t, const double y[], double *dfdy, double dfdt[], +- void *params); +- size_t dimension; +- void *params; +-} +-gsl_odeiv2_system; +- +-/* Function evaluation macros */ +- +-#define GSL_ODEIV_FN_EVAL(S,t,y,f) (*((S)->function))(t,y,f,(S)->params) +-#define GSL_ODEIV_JA_EVAL(S,t,y,dfdy,dfdt) (*((S)->jacobian))(t,y,dfdy,dfdt,(S)->params) +- +-/* Type definitions */ +- +-typedef struct gsl_odeiv2_step_struct gsl_odeiv2_step; +-typedef struct gsl_odeiv2_control_struct gsl_odeiv2_control; +-typedef struct gsl_odeiv2_evolve_struct gsl_odeiv2_evolve; +-typedef struct gsl_odeiv2_driver_struct gsl_odeiv2_driver; +- +-/* Stepper object +- * +- * Opaque object for stepping an ODE system from t to t+h. +- * In general the object has some state which facilitates +- * iterating the stepping operation. +- */ +- +-typedef struct +-{ +- const char *name; +- int can_use_dydt_in; +- int gives_exact_dydt_out; +- void *(*alloc) (size_t dim); +- int (*apply) (void *state, size_t dim, double t, double h, double y[], +- double yerr[], const double dydt_in[], double dydt_out[], +- const gsl_odeiv2_system * dydt); +- int (*set_driver) (void *state, const gsl_odeiv2_driver * d); +- int (*reset) (void *state, size_t dim); +- unsigned int (*order) (void *state); +- void (*free) (void *state); +-} +-gsl_odeiv2_step_type; +- +-struct gsl_odeiv2_step_struct +-{ +- const gsl_odeiv2_step_type *type; +- size_t dimension; +- void *state; +-}; +- +-/* Available stepper types */ +- +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk2; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk4; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rkf45; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rkck; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk8pd; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk2imp; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk4imp; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_bsimp; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_rk1imp; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_msadams; +-GSL_VAR const gsl_odeiv2_step_type *gsl_odeiv2_step_msbdf; +- +-/* Stepper object methods */ +- +-gsl_odeiv2_step *gsl_odeiv2_step_alloc (const gsl_odeiv2_step_type * T, +- size_t dim); +-int gsl_odeiv2_step_reset (gsl_odeiv2_step * s); +-void gsl_odeiv2_step_free (gsl_odeiv2_step * s); +-const char *gsl_odeiv2_step_name (const gsl_odeiv2_step * s); +-unsigned int gsl_odeiv2_step_order (const gsl_odeiv2_step * s); +-int gsl_odeiv2_step_apply (gsl_odeiv2_step * s, double t, double h, +- double y[], double yerr[], const double dydt_in[], +- double dydt_out[], const gsl_odeiv2_system * dydt); +-int gsl_odeiv2_step_set_driver (gsl_odeiv2_step * s, +- const gsl_odeiv2_driver * d); +- +-/* Step size control object. */ +- +-typedef struct +-{ +- const char *name; +- void *(*alloc) (void); +- int (*init) (void *state, double eps_abs, double eps_rel, double a_y, +- double a_dydt); +- int (*hadjust) (void *state, size_t dim, unsigned int ord, const double y[], +- const double yerr[], const double yp[], double *h); +- int (*errlevel) (void *state, const double y, const double dydt, +- const double h, const size_t ind, double *errlev); +- int (*set_driver) (void *state, const gsl_odeiv2_driver * d); +- void (*free) (void *state); +-} +-gsl_odeiv2_control_type; +- +-struct gsl_odeiv2_control_struct +-{ +- const gsl_odeiv2_control_type *type; +- void *state; +-}; +- +-/* Possible return values for an hadjust() evolution method */ +- +-#define GSL_ODEIV_HADJ_INC 1 /* step was increased */ +-#define GSL_ODEIV_HADJ_NIL 0 /* step unchanged */ +-#define GSL_ODEIV_HADJ_DEC (-1) /* step decreased */ +- +-/* General step size control methods. +- * +- * The hadjust() method controls the adjustment of +- * step size given the result of a step and the error. +- * Valid hadjust() methods must return one of the codes below. +- * errlevel function calculates the desired error level D0. +- * +- * The general data can be used by specializations +- * to store state and control their heuristics. +- */ +- +-gsl_odeiv2_control *gsl_odeiv2_control_alloc (const gsl_odeiv2_control_type * +- T); +-int gsl_odeiv2_control_init (gsl_odeiv2_control * c, double eps_abs, +- double eps_rel, double a_y, double a_dydt); +-void gsl_odeiv2_control_free (gsl_odeiv2_control * c); +-int gsl_odeiv2_control_hadjust (gsl_odeiv2_control * c, gsl_odeiv2_step * s, +- const double y[], const double yerr[], +- const double dydt[], double *h); +-const char *gsl_odeiv2_control_name (const gsl_odeiv2_control * c); +-int gsl_odeiv2_control_errlevel (gsl_odeiv2_control * c, const double y, +- const double dydt, const double h, +- const size_t ind, double *errlev); +-int gsl_odeiv2_control_set_driver (gsl_odeiv2_control * c, +- const gsl_odeiv2_driver * d); +- +-/* Available control object constructors. +- * +- * The standard control object is a four parameter heuristic +- * defined as follows: +- * D0 = eps_abs + eps_rel * (a_y |y| + a_dydt h |y'|) +- * D1 = |yerr| +- * q = consistency order of method (q=4 for 4(5) embedded RK) +- * S = safety factor (0.9 say) +- * +- * / (D0/D1)^(1/(q+1)) D0 >= D1 +- * h_NEW = S h_OLD * | +- * \ (D0/D1)^(1/q) D0 < D1 +- * +- * This encompasses all the standard error scaling methods. +- * +- * The y method is the standard method with a_y=1, a_dydt=0. +- * The yp method is the standard method with a_y=0, a_dydt=1. +- */ +- +-gsl_odeiv2_control *gsl_odeiv2_control_standard_new (double eps_abs, +- double eps_rel, +- double a_y, +- double a_dydt); +-gsl_odeiv2_control *gsl_odeiv2_control_y_new (double eps_abs, double eps_rel); +-gsl_odeiv2_control *gsl_odeiv2_control_yp_new (double eps_abs, +- double eps_rel); +- +-/* This controller computes errors using different absolute errors for +- * each component +- * +- * D0 = eps_abs * scale_abs[i] + eps_rel * (a_y |y| + a_dydt h |y'|) +- */ +- +-gsl_odeiv2_control *gsl_odeiv2_control_scaled_new (double eps_abs, +- double eps_rel, double a_y, +- double a_dydt, +- const double scale_abs[], +- size_t dim); +- +-/* Evolution object */ +- +-struct gsl_odeiv2_evolve_struct +-{ +- size_t dimension; +- double *y0; +- double *yerr; +- double *dydt_in; +- double *dydt_out; +- double last_step; +- unsigned long int count; +- unsigned long int failed_steps; +- const gsl_odeiv2_driver *driver; +-}; +- +-/* Evolution object methods */ +- +-gsl_odeiv2_evolve *gsl_odeiv2_evolve_alloc (size_t dim); +-int gsl_odeiv2_evolve_apply (gsl_odeiv2_evolve * e, gsl_odeiv2_control * con, +- gsl_odeiv2_step * step, +- const gsl_odeiv2_system * dydt, double *t, +- double t1, double *h, double y[]); +-int gsl_odeiv2_evolve_apply_fixed_step (gsl_odeiv2_evolve * e, +- gsl_odeiv2_control * con, +- gsl_odeiv2_step * step, +- const gsl_odeiv2_system * dydt, +- double *t, const double h0, +- double y[]); +-int gsl_odeiv2_evolve_reset (gsl_odeiv2_evolve * e); +-void gsl_odeiv2_evolve_free (gsl_odeiv2_evolve * e); +-int gsl_odeiv2_evolve_set_driver (gsl_odeiv2_evolve * e, +- const gsl_odeiv2_driver * d); +- +-/* Driver object +- * +- * This is a high level wrapper for step, control and +- * evolve objects. +- */ +- +-struct gsl_odeiv2_driver_struct +-{ +- const gsl_odeiv2_system *sys; /* ODE system */ +- gsl_odeiv2_step *s; /* stepper object */ +- gsl_odeiv2_control *c; /* control object */ +- gsl_odeiv2_evolve *e; /* evolve object */ +- double h; /* step size */ +- double hmin; /* minimum step size allowed */ +- double hmax; /* maximum step size allowed */ +- unsigned long int n; /* number of steps taken */ +- unsigned long int nmax; /* Maximum number of steps allowed */ +-}; +- +-/* Driver object methods */ +- +-gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_y_new (const gsl_odeiv2_system * +- sys, +- const gsl_odeiv2_step_type * +- T, const double hstart, +- const double epsabs, +- const double epsrel); +-gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_yp_new (const gsl_odeiv2_system * +- sys, +- const gsl_odeiv2_step_type +- * T, const double hstart, +- const double epsabs, +- const double epsrel); +-gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_scaled_new (const gsl_odeiv2_system +- * sys, +- const +- gsl_odeiv2_step_type * +- T, const double hstart, +- const double epsabs, +- const double epsrel, +- const double a_y, +- const double a_dydt, +- const double +- scale_abs[]); +-gsl_odeiv2_driver *gsl_odeiv2_driver_alloc_standard_new (const +- gsl_odeiv2_system * +- sys, +- const +- gsl_odeiv2_step_type +- * T, +- const double hstart, +- const double epsabs, +- const double epsrel, +- const double a_y, +- const double a_dydt); +-int gsl_odeiv2_driver_set_hmin (gsl_odeiv2_driver * d, const double hmin); +-int gsl_odeiv2_driver_set_hmax (gsl_odeiv2_driver * d, const double hmax); +-int gsl_odeiv2_driver_set_nmax (gsl_odeiv2_driver * d, +- const unsigned long int nmax); +-int gsl_odeiv2_driver_apply (gsl_odeiv2_driver * d, double *t, +- const double t1, double y[]); +-int gsl_odeiv2_driver_apply_fixed_step (gsl_odeiv2_driver * d, double *t, +- const double h, +- const unsigned long int n, +- double y[]); +-int gsl_odeiv2_driver_reset (gsl_odeiv2_driver * d); +-void gsl_odeiv2_driver_free (gsl_odeiv2_driver * state); +- +-__END_DECLS +-#endif /* __GSL_ODEIV2_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_check_range.h (revision 14079) +@@ -1,57 +0,0 @@ +-/* vector/gsl_check_range.h +- * +- * Copyright (C) 2003, 2004, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CHECK_RANGE_H__ +-#define __GSL_CHECK_RANGE_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-GSL_VAR int gsl_check_range; +- +-/* Turn range checking on by default, unless the user defines +- GSL_RANGE_CHECK_OFF, or defines GSL_RANGE_CHECK to 0 explicitly */ +- +-#ifdef GSL_RANGE_CHECK_OFF +-# ifndef GSL_RANGE_CHECK +-# define GSL_RANGE_CHECK 0 +-# else +-# error "cannot set both GSL_RANGE_CHECK and GSL_RANGE_CHECK_OFF" +-# endif +-#else +-# ifndef GSL_RANGE_CHECK +-# define GSL_RANGE_CHECK 1 +-# endif +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_CHECK_RANGE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block.h (revision 14079) +@@ -1,24 +0,0 @@ +-#ifndef __GSL_BLOCK_H__ +-#define __GSL_BLOCK_H__ +- +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_BLOCK_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ulong.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_ULONG_H__ +-#define __GSL_SORT_ULONG_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_ulong (unsigned long * data, const size_t stride, const size_t n); +-void gsl_sort_ulong_index (size_t * p, const unsigned long * data, const size_t stride, const size_t n); +- +-int gsl_sort_ulong_smallest (unsigned long * dest, const size_t k, const unsigned long * src, const size_t stride, const size_t n); +-int gsl_sort_ulong_smallest_index (size_t * p, const size_t k, const unsigned long * src, const size_t stride, const size_t n); +- +-int gsl_sort_ulong_largest (unsigned long * dest, const size_t k, const unsigned long * src, const size_t stride, const size_t n); +-int gsl_sort_ulong_largest_index (size_t * p, const size_t k, const unsigned long * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_precision.h (revision 14079) +@@ -1,66 +0,0 @@ +-/* gsl_precision.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: B. Gough and G. Jungman */ +- +-#ifndef __GSL_PRECISION_H__ +-#define __GSL_PRECISION_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* A type for the precision indicator. +- * This is mainly for pedagogy. +- */ +-typedef unsigned int gsl_prec_t; +- +- +-/* The number of precision types. +- * Remember that precision-mode +- * can index an array. +- */ +-#define _GSL_PREC_T_NUM 3 +- +- +-/* Arrays containing derived +- * precision constants for the +- * different precision levels. +- */ +-GSL_VAR const double gsl_prec_eps[]; +-GSL_VAR const double gsl_prec_sqrt_eps[]; +-GSL_VAR const double gsl_prec_root3_eps[]; +-GSL_VAR const double gsl_prec_root4_eps[]; +-GSL_VAR const double gsl_prec_root5_eps[]; +-GSL_VAR const double gsl_prec_root6_eps[]; +- +- +-__END_DECLS +- +-#endif /* __GSL_PRECISION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cdf.h (revision 14079) +@@ -1,170 +0,0 @@ +-/* cdf/gsl_cdf.h +- * +- * Copyright (C) 2002 Jason H. Stover. +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. +- */ +- +-/* Author: J. Stover */ +- +-#ifndef __GSL_CDF_H__ +-#define __GSL_CDF_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_cdf_ugaussian_P (const double x); +-double gsl_cdf_ugaussian_Q (const double x); +- +-double gsl_cdf_ugaussian_Pinv (const double P); +-double gsl_cdf_ugaussian_Qinv (const double Q); +- +-double gsl_cdf_gaussian_P (const double x, const double sigma); +-double gsl_cdf_gaussian_Q (const double x, const double sigma); +- +-double gsl_cdf_gaussian_Pinv (const double P, const double sigma); +-double gsl_cdf_gaussian_Qinv (const double Q, const double sigma); +- +-double gsl_cdf_gamma_P (const double x, const double a, const double b); +-double gsl_cdf_gamma_Q (const double x, const double a, const double b); +- +-double gsl_cdf_gamma_Pinv (const double P, const double a, const double b); +-double gsl_cdf_gamma_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_cauchy_P (const double x, const double a); +-double gsl_cdf_cauchy_Q (const double x, const double a); +- +-double gsl_cdf_cauchy_Pinv (const double P, const double a); +-double gsl_cdf_cauchy_Qinv (const double Q, const double a); +- +-double gsl_cdf_laplace_P (const double x, const double a); +-double gsl_cdf_laplace_Q (const double x, const double a); +- +-double gsl_cdf_laplace_Pinv (const double P, const double a); +-double gsl_cdf_laplace_Qinv (const double Q, const double a); +- +-double gsl_cdf_rayleigh_P (const double x, const double sigma); +-double gsl_cdf_rayleigh_Q (const double x, const double sigma); +- +-double gsl_cdf_rayleigh_Pinv (const double P, const double sigma); +-double gsl_cdf_rayleigh_Qinv (const double Q, const double sigma); +- +-double gsl_cdf_chisq_P (const double x, const double nu); +-double gsl_cdf_chisq_Q (const double x, const double nu); +- +-double gsl_cdf_chisq_Pinv (const double P, const double nu); +-double gsl_cdf_chisq_Qinv (const double Q, const double nu); +- +-double gsl_cdf_exponential_P (const double x, const double mu); +-double gsl_cdf_exponential_Q (const double x, const double mu); +- +-double gsl_cdf_exponential_Pinv (const double P, const double mu); +-double gsl_cdf_exponential_Qinv (const double Q, const double mu); +- +-double gsl_cdf_exppow_P (const double x, const double a, const double b); +-double gsl_cdf_exppow_Q (const double x, const double a, const double b); +- +-double gsl_cdf_tdist_P (const double x, const double nu); +-double gsl_cdf_tdist_Q (const double x, const double nu); +- +-double gsl_cdf_tdist_Pinv (const double P, const double nu); +-double gsl_cdf_tdist_Qinv (const double Q, const double nu); +- +-double gsl_cdf_fdist_P (const double x, const double nu1, const double nu2); +-double gsl_cdf_fdist_Q (const double x, const double nu1, const double nu2); +- +-double gsl_cdf_fdist_Pinv (const double P, const double nu1, const double nu2); +-double gsl_cdf_fdist_Qinv (const double Q, const double nu1, const double nu2); +- +-double gsl_cdf_beta_P (const double x, const double a, const double b); +-double gsl_cdf_beta_Q (const double x, const double a, const double b); +- +-double gsl_cdf_beta_Pinv (const double P, const double a, const double b); +-double gsl_cdf_beta_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_flat_P (const double x, const double a, const double b); +-double gsl_cdf_flat_Q (const double x, const double a, const double b); +- +-double gsl_cdf_flat_Pinv (const double P, const double a, const double b); +-double gsl_cdf_flat_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_lognormal_P (const double x, const double zeta, const double sigma); +-double gsl_cdf_lognormal_Q (const double x, const double zeta, const double sigma); +- +-double gsl_cdf_lognormal_Pinv (const double P, const double zeta, const double sigma); +-double gsl_cdf_lognormal_Qinv (const double Q, const double zeta, const double sigma); +- +-double gsl_cdf_gumbel1_P (const double x, const double a, const double b); +-double gsl_cdf_gumbel1_Q (const double x, const double a, const double b); +- +-double gsl_cdf_gumbel1_Pinv (const double P, const double a, const double b); +-double gsl_cdf_gumbel1_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_gumbel2_P (const double x, const double a, const double b); +-double gsl_cdf_gumbel2_Q (const double x, const double a, const double b); +- +-double gsl_cdf_gumbel2_Pinv (const double P, const double a, const double b); +-double gsl_cdf_gumbel2_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_weibull_P (const double x, const double a, const double b); +-double gsl_cdf_weibull_Q (const double x, const double a, const double b); +- +-double gsl_cdf_weibull_Pinv (const double P, const double a, const double b); +-double gsl_cdf_weibull_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_pareto_P (const double x, const double a, const double b); +-double gsl_cdf_pareto_Q (const double x, const double a, const double b); +- +-double gsl_cdf_pareto_Pinv (const double P, const double a, const double b); +-double gsl_cdf_pareto_Qinv (const double Q, const double a, const double b); +- +-double gsl_cdf_logistic_P (const double x, const double a); +-double gsl_cdf_logistic_Q (const double x, const double a); +- +-double gsl_cdf_logistic_Pinv (const double P, const double a); +-double gsl_cdf_logistic_Qinv (const double Q, const double a); +- +-double gsl_cdf_binomial_P (const unsigned int k, const double p, const unsigned int n); +-double gsl_cdf_binomial_Q (const unsigned int k, const double p, const unsigned int n); +- +-double gsl_cdf_poisson_P (const unsigned int k, const double mu); +-double gsl_cdf_poisson_Q (const unsigned int k, const double mu); +- +-double gsl_cdf_geometric_P (const unsigned int k, const double p); +-double gsl_cdf_geometric_Q (const unsigned int k, const double p); +- +-double gsl_cdf_negative_binomial_P (const unsigned int k, const double p, const double n); +-double gsl_cdf_negative_binomial_Q (const unsigned int k, const double p, const double n); +- +-double gsl_cdf_pascal_P (const unsigned int k, const double p, const unsigned int n); +-double gsl_cdf_pascal_Q (const unsigned int k, const double p, const unsigned int n); +- +-double gsl_cdf_hypergeometric_P (const unsigned int k, const unsigned int n1, +- const unsigned int n2, const unsigned int t); +-double gsl_cdf_hypergeometric_Q (const unsigned int k, const unsigned int n1, +- const unsigned int n2, const unsigned int t); +- +-__END_DECLS +- +-#endif /* __GSL_CDF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multifit.h (revision 14079) +@@ -1,130 +0,0 @@ +-/* multifit/gsl_multifit.h +- * +- * Copyright (C) 2000, 2007, 2010 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MULTIFIT_H__ +-#define __GSL_MULTIFIT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t n; /* number of observations */ +- size_t p; /* number of parameters */ +- gsl_matrix * A; +- gsl_matrix * Q; +- gsl_matrix * QSI; +- gsl_vector * S; +- gsl_vector * t; +- gsl_vector * xt; +- gsl_vector * D; +-} +-gsl_multifit_linear_workspace; +- +-gsl_multifit_linear_workspace * +-gsl_multifit_linear_alloc (size_t n, size_t p); +- +-void +-gsl_multifit_linear_free (gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_linear (const gsl_matrix * X, +- const gsl_vector * y, +- gsl_vector * c, +- gsl_matrix * cov, +- double * chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_linear_svd (const gsl_matrix * X, +- const gsl_vector * y, +- double tol, +- size_t * rank, +- gsl_vector * c, +- gsl_matrix * cov, +- double *chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_linear_usvd (const gsl_matrix * X, +- const gsl_vector * y, +- double tol, +- size_t * rank, +- gsl_vector * c, +- gsl_matrix * cov, +- double *chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_wlinear (const gsl_matrix * X, +- const gsl_vector * w, +- const gsl_vector * y, +- gsl_vector * c, +- gsl_matrix * cov, +- double * chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_wlinear_svd (const gsl_matrix * X, +- const gsl_vector * w, +- const gsl_vector * y, +- double tol, +- size_t * rank, +- gsl_vector * c, +- gsl_matrix * cov, +- double *chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_wlinear_usvd (const gsl_matrix * X, +- const gsl_vector * w, +- const gsl_vector * y, +- double tol, +- size_t * rank, +- gsl_vector * c, +- gsl_matrix * cov, +- double *chisq, +- gsl_multifit_linear_workspace * work); +- +-int +-gsl_multifit_linear_est (const gsl_vector * x, +- const gsl_vector * c, +- const gsl_matrix * cov, double *y, double *y_err); +- +-int +-gsl_multifit_linear_residuals (const gsl_matrix *X, const gsl_vector *y, +- const gsl_vector *c, gsl_vector *r); +- +-__END_DECLS +- +-#endif /* __GSL_MULTIFIT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_complex_float.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_COMPLEX_FLOAT_H__ +-#define __GSL_PERMUTE_COMPLEX_FLOAT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_complex_float (const size_t * p, float * data, const size_t stride, const size_t n); +-int gsl_permute_complex_float_inverse (const size_t * p, float * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_COMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multimin.h (revision 14079) +@@ -1,226 +0,0 @@ +-/* multimin/gsl_multimin.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Fabrice Rossi +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Modified by Tuomo Keskitalo to include fminimizer and +- Nelder Mead related lines */ +- +-#ifndef __GSL_MULTIMIN_H__ +-#define __GSL_MULTIMIN_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Definition of an arbitrary real-valued function with gsl_vector input and */ +-/* parameters */ +-struct gsl_multimin_function_struct +-{ +- double (* f) (const gsl_vector * x, void * params); +- size_t n; +- void * params; +-}; +- +-typedef struct gsl_multimin_function_struct gsl_multimin_function; +- +-#define GSL_MULTIMIN_FN_EVAL(F,x) (*((F)->f))(x,(F)->params) +- +-/* Definition of an arbitrary differentiable real-valued function */ +-/* with gsl_vector input and parameters */ +-struct gsl_multimin_function_fdf_struct +-{ +- double (* f) (const gsl_vector * x, void * params); +- void (* df) (const gsl_vector * x, void * params,gsl_vector * df); +- void (* fdf) (const gsl_vector * x, void * params,double *f,gsl_vector * df); +- size_t n; +- void * params; +-}; +- +-typedef struct gsl_multimin_function_fdf_struct gsl_multimin_function_fdf; +- +-#define GSL_MULTIMIN_FN_EVAL_F(F,x) (*((F)->f))(x,(F)->params) +-#define GSL_MULTIMIN_FN_EVAL_DF(F,x,g) (*((F)->df))(x,(F)->params,(g)) +-#define GSL_MULTIMIN_FN_EVAL_F_DF(F,x,y,g) (*((F)->fdf))(x,(F)->params,(y),(g)) +- +-int gsl_multimin_diff (const gsl_multimin_function * f, +- const gsl_vector * x, gsl_vector * g); +- +-/* minimization of non-differentiable functions */ +- +-typedef struct +-{ +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n); +- int (*set) (void *state, gsl_multimin_function * f, +- const gsl_vector * x, +- double * size, +- const gsl_vector * step_size); +- int (*iterate) (void *state, gsl_multimin_function * f, +- gsl_vector * x, +- double * size, +- double * fval); +- void (*free) (void *state); +-} +-gsl_multimin_fminimizer_type; +- +-typedef struct +-{ +- /* multi dimensional part */ +- const gsl_multimin_fminimizer_type *type; +- gsl_multimin_function *f; +- +- double fval; +- gsl_vector * x; +- +- double size; +- +- void *state; +-} +-gsl_multimin_fminimizer; +- +-gsl_multimin_fminimizer * +-gsl_multimin_fminimizer_alloc(const gsl_multimin_fminimizer_type *T, +- size_t n); +- +-int +-gsl_multimin_fminimizer_set (gsl_multimin_fminimizer * s, +- gsl_multimin_function * f, +- const gsl_vector * x, +- const gsl_vector * step_size); +- +-void +-gsl_multimin_fminimizer_free(gsl_multimin_fminimizer *s); +- +-const char * +-gsl_multimin_fminimizer_name (const gsl_multimin_fminimizer * s); +- +-int +-gsl_multimin_fminimizer_iterate(gsl_multimin_fminimizer *s); +- +-gsl_vector * +-gsl_multimin_fminimizer_x (const gsl_multimin_fminimizer * s); +- +-double +-gsl_multimin_fminimizer_minimum (const gsl_multimin_fminimizer * s); +- +-double +-gsl_multimin_fminimizer_size (const gsl_multimin_fminimizer * s); +- +-/* Convergence test functions */ +- +-int +-gsl_multimin_test_gradient(const gsl_vector * g, double epsabs); +- +-int +-gsl_multimin_test_size(const double size, double epsabs); +- +-/* minimisation of differentiable functions */ +- +-typedef struct +-{ +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n); +- int (*set) (void *state, gsl_multimin_function_fdf * fdf, +- const gsl_vector * x, double * f, +- gsl_vector * gradient, double step_size, double tol); +- int (*iterate) (void *state,gsl_multimin_function_fdf * fdf, +- gsl_vector * x, double * f, +- gsl_vector * gradient, gsl_vector * dx); +- int (*restart) (void *state); +- void (*free) (void *state); +-} +-gsl_multimin_fdfminimizer_type; +- +-typedef struct +-{ +- /* multi dimensional part */ +- const gsl_multimin_fdfminimizer_type *type; +- gsl_multimin_function_fdf *fdf; +- +- double f; +- gsl_vector * x; +- gsl_vector * gradient; +- gsl_vector * dx; +- +- void *state; +-} +-gsl_multimin_fdfminimizer; +- +-gsl_multimin_fdfminimizer * +-gsl_multimin_fdfminimizer_alloc(const gsl_multimin_fdfminimizer_type *T, +- size_t n); +- +-int +-gsl_multimin_fdfminimizer_set (gsl_multimin_fdfminimizer * s, +- gsl_multimin_function_fdf *fdf, +- const gsl_vector * x, +- double step_size, double tol); +- +-void +-gsl_multimin_fdfminimizer_free(gsl_multimin_fdfminimizer *s); +- +-const char * +-gsl_multimin_fdfminimizer_name (const gsl_multimin_fdfminimizer * s); +- +-int +-gsl_multimin_fdfminimizer_iterate(gsl_multimin_fdfminimizer *s); +- +-int +-gsl_multimin_fdfminimizer_restart(gsl_multimin_fdfminimizer *s); +- +-gsl_vector * +-gsl_multimin_fdfminimizer_x (const gsl_multimin_fdfminimizer * s); +- +-gsl_vector * +-gsl_multimin_fdfminimizer_dx (const gsl_multimin_fdfminimizer * s); +- +-gsl_vector * +-gsl_multimin_fdfminimizer_gradient (const gsl_multimin_fdfminimizer * s); +- +-double +-gsl_multimin_fdfminimizer_minimum (const gsl_multimin_fdfminimizer * s); +- +-GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_steepest_descent; +-GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_conjugate_pr; +-GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_conjugate_fr; +-GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_vector_bfgs; +-GSL_VAR const gsl_multimin_fdfminimizer_type *gsl_multimin_fdfminimizer_vector_bfgs2; +-GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex; +-GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex2; +-GSL_VAR const gsl_multimin_fminimizer_type *gsl_multimin_fminimizer_nmsimplex2rand; +- +-__END_DECLS +- +-#endif /* __GSL_MULTIMIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_double.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_DOUBLE_H__ +-#define __GSL_MATRIX_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- double * data; +- gsl_block * block; +- int owner; +-} gsl_matrix; +- +-typedef struct +-{ +- gsl_matrix matrix; +-} _gsl_matrix_view; +- +-typedef _gsl_matrix_view gsl_matrix_view; +- +-typedef struct +-{ +- gsl_matrix matrix; +-} _gsl_matrix_const_view; +- +-typedef const _gsl_matrix_const_view gsl_matrix_const_view; +- +-/* Allocation */ +- +-gsl_matrix * +-gsl_matrix_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix * +-gsl_matrix_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix * +-gsl_matrix_alloc_from_block (gsl_block * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix * +-gsl_matrix_alloc_from_matrix (gsl_matrix * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector * +-gsl_vector_alloc_row_from_matrix (gsl_matrix * m, +- const size_t i); +- +-gsl_vector * +-gsl_vector_alloc_col_from_matrix (gsl_matrix * m, +- const size_t j); +- +-void gsl_matrix_free (gsl_matrix * m); +- +-/* Views */ +- +-_gsl_matrix_view +-gsl_matrix_submatrix (gsl_matrix * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_view +-gsl_matrix_row (gsl_matrix * m, const size_t i); +- +-_gsl_vector_view +-gsl_matrix_column (gsl_matrix * m, const size_t j); +- +-_gsl_vector_view +-gsl_matrix_diagonal (gsl_matrix * m); +- +-_gsl_vector_view +-gsl_matrix_subdiagonal (gsl_matrix * m, const size_t k); +- +-_gsl_vector_view +-gsl_matrix_superdiagonal (gsl_matrix * m, const size_t k); +- +-_gsl_vector_view +-gsl_matrix_subrow (gsl_matrix * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_view +-gsl_matrix_subcolumn (gsl_matrix * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_view +-gsl_matrix_view_array (double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_view +-gsl_matrix_view_array_with_tda (double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_view +-gsl_matrix_view_vector (gsl_vector * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_view +-gsl_matrix_view_vector_with_tda (gsl_vector * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_const_view +-gsl_matrix_const_submatrix (const gsl_matrix * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_const_view +-gsl_matrix_const_row (const gsl_matrix * m, +- const size_t i); +- +-_gsl_vector_const_view +-gsl_matrix_const_column (const gsl_matrix * m, +- const size_t j); +- +-_gsl_vector_const_view +-gsl_matrix_const_diagonal (const gsl_matrix * m); +- +-_gsl_vector_const_view +-gsl_matrix_const_subdiagonal (const gsl_matrix * m, +- const size_t k); +- +-_gsl_vector_const_view +-gsl_matrix_const_superdiagonal (const gsl_matrix * m, +- const size_t k); +- +-_gsl_vector_const_view +-gsl_matrix_const_subrow (const gsl_matrix * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_const_view +-gsl_matrix_const_subcolumn (const gsl_matrix * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_const_view +-gsl_matrix_const_view_array (const double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_const_view +-gsl_matrix_const_view_array_with_tda (const double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_const_view +-gsl_matrix_const_view_vector (const gsl_vector * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_const_view +-gsl_matrix_const_view_vector_with_tda (const gsl_vector * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_set_zero (gsl_matrix * m); +-void gsl_matrix_set_identity (gsl_matrix * m); +-void gsl_matrix_set_all (gsl_matrix * m, double x); +- +-int gsl_matrix_fread (FILE * stream, gsl_matrix * m) ; +-int gsl_matrix_fwrite (FILE * stream, const gsl_matrix * m) ; +-int gsl_matrix_fscanf (FILE * stream, gsl_matrix * m); +-int gsl_matrix_fprintf (FILE * stream, const gsl_matrix * m, const char * format); +- +-int gsl_matrix_memcpy(gsl_matrix * dest, const gsl_matrix * src); +-int gsl_matrix_swap(gsl_matrix * m1, gsl_matrix * m2); +- +-int gsl_matrix_swap_rows(gsl_matrix * m, const size_t i, const size_t j); +-int gsl_matrix_swap_columns(gsl_matrix * m, const size_t i, const size_t j); +-int gsl_matrix_swap_rowcol(gsl_matrix * m, const size_t i, const size_t j); +-int gsl_matrix_transpose (gsl_matrix * m); +-int gsl_matrix_transpose_memcpy (gsl_matrix * dest, const gsl_matrix * src); +- +-double gsl_matrix_max (const gsl_matrix * m); +-double gsl_matrix_min (const gsl_matrix * m); +-void gsl_matrix_minmax (const gsl_matrix * m, double * min_out, double * max_out); +- +-void gsl_matrix_max_index (const gsl_matrix * m, size_t * imax, size_t *jmax); +-void gsl_matrix_min_index (const gsl_matrix * m, size_t * imin, size_t *jmin); +-void gsl_matrix_minmax_index (const gsl_matrix * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_equal (const gsl_matrix * a, const gsl_matrix * b); +- +-int gsl_matrix_isnull (const gsl_matrix * m); +-int gsl_matrix_ispos (const gsl_matrix * m); +-int gsl_matrix_isneg (const gsl_matrix * m); +-int gsl_matrix_isnonneg (const gsl_matrix * m); +- +-int gsl_matrix_add (gsl_matrix * a, const gsl_matrix * b); +-int gsl_matrix_sub (gsl_matrix * a, const gsl_matrix * b); +-int gsl_matrix_mul_elements (gsl_matrix * a, const gsl_matrix * b); +-int gsl_matrix_div_elements (gsl_matrix * a, const gsl_matrix * b); +-int gsl_matrix_scale (gsl_matrix * a, const double x); +-int gsl_matrix_add_constant (gsl_matrix * a, const double x); +-int gsl_matrix_add_diagonal (gsl_matrix * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_get_row(gsl_vector * v, const gsl_matrix * m, const size_t i); +-int gsl_matrix_get_col(gsl_vector * v, const gsl_matrix * m, const size_t j); +-int gsl_matrix_set_row(gsl_matrix * m, const size_t i, const gsl_vector * v); +-int gsl_matrix_set_col(gsl_matrix * m, const size_t j, const gsl_vector * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL double gsl_matrix_get(const gsl_matrix * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_set(gsl_matrix * m, const size_t i, const size_t j, const double x); +-INLINE_DECL double * gsl_matrix_ptr(gsl_matrix * m, const size_t i, const size_t j); +-INLINE_DECL const double * gsl_matrix_const_ptr(const gsl_matrix * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-double +-gsl_matrix_get(const gsl_matrix * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_set(gsl_matrix * m, const size_t i, const size_t j, const double x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-double * +-gsl_matrix_ptr(gsl_matrix * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (double *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const double * +-gsl_matrix_const_ptr(const gsl_matrix * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const double *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgsm.h (revision 14079) +@@ -1,122 +0,0 @@ +-/* const/gsl_const_cgsm.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- * 2006, 2007, 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST_CGSM__ +-#define __GSL_CONST_CGSM__ +- +-#define GSL_CONST_CGSM_SPEED_OF_LIGHT (2.99792458e10) /* cm / s */ +-#define GSL_CONST_CGSM_GRAVITATIONAL_CONSTANT (6.673e-8) /* cm^3 / g s^2 */ +-#define GSL_CONST_CGSM_PLANCKS_CONSTANT_H (6.62606896e-27) /* g cm^2 / s */ +-#define GSL_CONST_CGSM_PLANCKS_CONSTANT_HBAR (1.05457162825e-27) /* g cm^2 / s */ +-#define GSL_CONST_CGSM_ASTRONOMICAL_UNIT (1.49597870691e13) /* cm */ +-#define GSL_CONST_CGSM_LIGHT_YEAR (9.46053620707e17) /* cm */ +-#define GSL_CONST_CGSM_PARSEC (3.08567758135e18) /* cm */ +-#define GSL_CONST_CGSM_GRAV_ACCEL (9.80665e2) /* cm / s^2 */ +-#define GSL_CONST_CGSM_ELECTRON_VOLT (1.602176487e-12) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_MASS_ELECTRON (9.10938188e-28) /* g */ +-#define GSL_CONST_CGSM_MASS_MUON (1.88353109e-25) /* g */ +-#define GSL_CONST_CGSM_MASS_PROTON (1.67262158e-24) /* g */ +-#define GSL_CONST_CGSM_MASS_NEUTRON (1.67492716e-24) /* g */ +-#define GSL_CONST_CGSM_RYDBERG (2.17987196968e-11) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_BOLTZMANN (1.3806504e-16) /* g cm^2 / K s^2 */ +-#define GSL_CONST_CGSM_MOLAR_GAS (8.314472e7) /* g cm^2 / K mol s^2 */ +-#define GSL_CONST_CGSM_STANDARD_GAS_VOLUME (2.2710981e4) /* cm^3 / mol */ +-#define GSL_CONST_CGSM_MINUTE (6e1) /* s */ +-#define GSL_CONST_CGSM_HOUR (3.6e3) /* s */ +-#define GSL_CONST_CGSM_DAY (8.64e4) /* s */ +-#define GSL_CONST_CGSM_WEEK (6.048e5) /* s */ +-#define GSL_CONST_CGSM_INCH (2.54e0) /* cm */ +-#define GSL_CONST_CGSM_FOOT (3.048e1) /* cm */ +-#define GSL_CONST_CGSM_YARD (9.144e1) /* cm */ +-#define GSL_CONST_CGSM_MILE (1.609344e5) /* cm */ +-#define GSL_CONST_CGSM_NAUTICAL_MILE (1.852e5) /* cm */ +-#define GSL_CONST_CGSM_FATHOM (1.8288e2) /* cm */ +-#define GSL_CONST_CGSM_MIL (2.54e-3) /* cm */ +-#define GSL_CONST_CGSM_POINT (3.52777777778e-2) /* cm */ +-#define GSL_CONST_CGSM_TEXPOINT (3.51459803515e-2) /* cm */ +-#define GSL_CONST_CGSM_MICRON (1e-4) /* cm */ +-#define GSL_CONST_CGSM_ANGSTROM (1e-8) /* cm */ +-#define GSL_CONST_CGSM_HECTARE (1e8) /* cm^2 */ +-#define GSL_CONST_CGSM_ACRE (4.04685642241e7) /* cm^2 */ +-#define GSL_CONST_CGSM_BARN (1e-24) /* cm^2 */ +-#define GSL_CONST_CGSM_LITER (1e3) /* cm^3 */ +-#define GSL_CONST_CGSM_US_GALLON (3.78541178402e3) /* cm^3 */ +-#define GSL_CONST_CGSM_QUART (9.46352946004e2) /* cm^3 */ +-#define GSL_CONST_CGSM_PINT (4.73176473002e2) /* cm^3 */ +-#define GSL_CONST_CGSM_CUP (2.36588236501e2) /* cm^3 */ +-#define GSL_CONST_CGSM_FLUID_OUNCE (2.95735295626e1) /* cm^3 */ +-#define GSL_CONST_CGSM_TABLESPOON (1.47867647813e1) /* cm^3 */ +-#define GSL_CONST_CGSM_TEASPOON (4.92892159375e0) /* cm^3 */ +-#define GSL_CONST_CGSM_CANADIAN_GALLON (4.54609e3) /* cm^3 */ +-#define GSL_CONST_CGSM_UK_GALLON (4.546092e3) /* cm^3 */ +-#define GSL_CONST_CGSM_MILES_PER_HOUR (4.4704e1) /* cm / s */ +-#define GSL_CONST_CGSM_KILOMETERS_PER_HOUR (2.77777777778e1) /* cm / s */ +-#define GSL_CONST_CGSM_KNOT (5.14444444444e1) /* cm / s */ +-#define GSL_CONST_CGSM_POUND_MASS (4.5359237e2) /* g */ +-#define GSL_CONST_CGSM_OUNCE_MASS (2.8349523125e1) /* g */ +-#define GSL_CONST_CGSM_TON (9.0718474e5) /* g */ +-#define GSL_CONST_CGSM_METRIC_TON (1e6) /* g */ +-#define GSL_CONST_CGSM_UK_TON (1.0160469088e6) /* g */ +-#define GSL_CONST_CGSM_TROY_OUNCE (3.1103475e1) /* g */ +-#define GSL_CONST_CGSM_CARAT (2e-1) /* g */ +-#define GSL_CONST_CGSM_UNIFIED_ATOMIC_MASS (1.660538782e-24) /* g */ +-#define GSL_CONST_CGSM_GRAM_FORCE (9.80665e2) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_POUND_FORCE (4.44822161526e5) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_KILOPOUND_FORCE (4.44822161526e8) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_POUNDAL (1.38255e4) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_CALORIE (4.1868e7) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_BTU (1.05505585262e10) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_THERM (1.05506e15) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_HORSEPOWER (7.457e9) /* g cm^2 / s^3 */ +-#define GSL_CONST_CGSM_BAR (1e6) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_STD_ATMOSPHERE (1.01325e6) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_TORR (1.33322368421e3) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_METER_OF_MERCURY (1.33322368421e6) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_INCH_OF_MERCURY (3.38638815789e4) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_INCH_OF_WATER (2.490889e3) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_PSI (6.89475729317e4) /* g / cm s^2 */ +-#define GSL_CONST_CGSM_POISE (1e0) /* g / cm s */ +-#define GSL_CONST_CGSM_STOKES (1e0) /* cm^2 / s */ +-#define GSL_CONST_CGSM_STILB (1e0) /* cd / cm^2 */ +-#define GSL_CONST_CGSM_LUMEN (1e0) /* cd sr */ +-#define GSL_CONST_CGSM_LUX (1e-4) /* cd sr / cm^2 */ +-#define GSL_CONST_CGSM_PHOT (1e0) /* cd sr / cm^2 */ +-#define GSL_CONST_CGSM_FOOTCANDLE (1.076e-3) /* cd sr / cm^2 */ +-#define GSL_CONST_CGSM_LAMBERT (1e0) /* cd sr / cm^2 */ +-#define GSL_CONST_CGSM_FOOTLAMBERT (1.07639104e-3) /* cd sr / cm^2 */ +-#define GSL_CONST_CGSM_CURIE (3.7e10) /* 1 / s */ +-#define GSL_CONST_CGSM_ROENTGEN (2.58e-8) /* abamp s / g */ +-#define GSL_CONST_CGSM_RAD (1e2) /* cm^2 / s^2 */ +-#define GSL_CONST_CGSM_SOLAR_MASS (1.98892e33) /* g */ +-#define GSL_CONST_CGSM_BOHR_RADIUS (5.291772083e-9) /* cm */ +-#define GSL_CONST_CGSM_NEWTON (1e5) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_DYNE (1e0) /* cm g / s^2 */ +-#define GSL_CONST_CGSM_JOULE (1e7) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_ERG (1e0) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGSM_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-5) /* g / K^4 s^3 */ +-#define GSL_CONST_CGSM_THOMSON_CROSS_SECTION (6.65245893699e-25) /* cm^2 */ +-#define GSL_CONST_CGSM_BOHR_MAGNETON (9.27400899e-21) /* abamp cm^2 */ +-#define GSL_CONST_CGSM_NUCLEAR_MAGNETON (5.05078317e-24) /* abamp cm^2 */ +-#define GSL_CONST_CGSM_ELECTRON_MAGNETIC_MOMENT (9.28476362e-21) /* abamp cm^2 */ +-#define GSL_CONST_CGSM_PROTON_MAGNETIC_MOMENT (1.410606633e-23) /* abamp cm^2 */ +-#define GSL_CONST_CGSM_FARADAY (9.64853429775e3) /* abamp s / mol */ +-#define GSL_CONST_CGSM_ELECTRON_CHARGE (1.602176487e-20) /* abamp s */ +- +-#endif /* __GSL_CONST_CGSM__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_uint.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_UINT_H__ +-#define __GSL_VECTOR_UINT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- unsigned int *data; +- gsl_block_uint *block; +- int owner; +-} +-gsl_vector_uint; +- +-typedef struct +-{ +- gsl_vector_uint vector; +-} _gsl_vector_uint_view; +- +-typedef _gsl_vector_uint_view gsl_vector_uint_view; +- +-typedef struct +-{ +- gsl_vector_uint vector; +-} _gsl_vector_uint_const_view; +- +-typedef const _gsl_vector_uint_const_view gsl_vector_uint_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_uint *gsl_vector_uint_alloc (const size_t n); +-gsl_vector_uint *gsl_vector_uint_calloc (const size_t n); +- +-gsl_vector_uint *gsl_vector_uint_alloc_from_block (gsl_block_uint * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_uint *gsl_vector_uint_alloc_from_vector (gsl_vector_uint * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_uint_free (gsl_vector_uint * v); +- +-/* Views */ +- +-_gsl_vector_uint_view +-gsl_vector_uint_view_array (unsigned int *v, size_t n); +- +-_gsl_vector_uint_view +-gsl_vector_uint_view_array_with_stride (unsigned int *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_uint_const_view +-gsl_vector_uint_const_view_array (const unsigned int *v, size_t n); +- +-_gsl_vector_uint_const_view +-gsl_vector_uint_const_view_array_with_stride (const unsigned int *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_uint_view +-gsl_vector_uint_subvector (gsl_vector_uint *v, +- size_t i, +- size_t n); +- +-_gsl_vector_uint_view +-gsl_vector_uint_subvector_with_stride (gsl_vector_uint *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_uint_const_view +-gsl_vector_uint_const_subvector (const gsl_vector_uint *v, +- size_t i, +- size_t n); +- +-_gsl_vector_uint_const_view +-gsl_vector_uint_const_subvector_with_stride (const gsl_vector_uint *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_uint_set_zero (gsl_vector_uint * v); +-void gsl_vector_uint_set_all (gsl_vector_uint * v, unsigned int x); +-int gsl_vector_uint_set_basis (gsl_vector_uint * v, size_t i); +- +-int gsl_vector_uint_fread (FILE * stream, gsl_vector_uint * v); +-int gsl_vector_uint_fwrite (FILE * stream, const gsl_vector_uint * v); +-int gsl_vector_uint_fscanf (FILE * stream, gsl_vector_uint * v); +-int gsl_vector_uint_fprintf (FILE * stream, const gsl_vector_uint * v, +- const char *format); +- +-int gsl_vector_uint_memcpy (gsl_vector_uint * dest, const gsl_vector_uint * src); +- +-int gsl_vector_uint_reverse (gsl_vector_uint * v); +- +-int gsl_vector_uint_swap (gsl_vector_uint * v, gsl_vector_uint * w); +-int gsl_vector_uint_swap_elements (gsl_vector_uint * v, const size_t i, const size_t j); +- +-unsigned int gsl_vector_uint_max (const gsl_vector_uint * v); +-unsigned int gsl_vector_uint_min (const gsl_vector_uint * v); +-void gsl_vector_uint_minmax (const gsl_vector_uint * v, unsigned int * min_out, unsigned int * max_out); +- +-size_t gsl_vector_uint_max_index (const gsl_vector_uint * v); +-size_t gsl_vector_uint_min_index (const gsl_vector_uint * v); +-void gsl_vector_uint_minmax_index (const gsl_vector_uint * v, size_t * imin, size_t * imax); +- +-int gsl_vector_uint_add (gsl_vector_uint * a, const gsl_vector_uint * b); +-int gsl_vector_uint_sub (gsl_vector_uint * a, const gsl_vector_uint * b); +-int gsl_vector_uint_mul (gsl_vector_uint * a, const gsl_vector_uint * b); +-int gsl_vector_uint_div (gsl_vector_uint * a, const gsl_vector_uint * b); +-int gsl_vector_uint_scale (gsl_vector_uint * a, const double x); +-int gsl_vector_uint_add_constant (gsl_vector_uint * a, const double x); +- +-int gsl_vector_uint_equal (const gsl_vector_uint * u, +- const gsl_vector_uint * v); +- +-int gsl_vector_uint_isnull (const gsl_vector_uint * v); +-int gsl_vector_uint_ispos (const gsl_vector_uint * v); +-int gsl_vector_uint_isneg (const gsl_vector_uint * v); +-int gsl_vector_uint_isnonneg (const gsl_vector_uint * v); +- +-INLINE_DECL unsigned int gsl_vector_uint_get (const gsl_vector_uint * v, const size_t i); +-INLINE_DECL void gsl_vector_uint_set (gsl_vector_uint * v, const size_t i, unsigned int x); +-INLINE_DECL unsigned int * gsl_vector_uint_ptr (gsl_vector_uint * v, const size_t i); +-INLINE_DECL const unsigned int * gsl_vector_uint_const_ptr (const gsl_vector_uint * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-unsigned int +-gsl_vector_uint_get (const gsl_vector_uint * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_uint_set (gsl_vector_uint * v, const size_t i, unsigned int x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-unsigned int * +-gsl_vector_uint_ptr (gsl_vector_uint * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (unsigned int *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const unsigned int * +-gsl_vector_uint_const_ptr (const gsl_vector_uint * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const unsigned int *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_UINT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_char.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_CHAR_H__ +-#define __GSL_MATRIX_CHAR_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- char * data; +- gsl_block_char * block; +- int owner; +-} gsl_matrix_char; +- +-typedef struct +-{ +- gsl_matrix_char matrix; +-} _gsl_matrix_char_view; +- +-typedef _gsl_matrix_char_view gsl_matrix_char_view; +- +-typedef struct +-{ +- gsl_matrix_char matrix; +-} _gsl_matrix_char_const_view; +- +-typedef const _gsl_matrix_char_const_view gsl_matrix_char_const_view; +- +-/* Allocation */ +- +-gsl_matrix_char * +-gsl_matrix_char_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_char * +-gsl_matrix_char_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_char * +-gsl_matrix_char_alloc_from_block (gsl_block_char * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_char * +-gsl_matrix_char_alloc_from_matrix (gsl_matrix_char * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_char * +-gsl_vector_char_alloc_row_from_matrix (gsl_matrix_char * m, +- const size_t i); +- +-gsl_vector_char * +-gsl_vector_char_alloc_col_from_matrix (gsl_matrix_char * m, +- const size_t j); +- +-void gsl_matrix_char_free (gsl_matrix_char * m); +- +-/* Views */ +- +-_gsl_matrix_char_view +-gsl_matrix_char_submatrix (gsl_matrix_char * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_char_view +-gsl_matrix_char_row (gsl_matrix_char * m, const size_t i); +- +-_gsl_vector_char_view +-gsl_matrix_char_column (gsl_matrix_char * m, const size_t j); +- +-_gsl_vector_char_view +-gsl_matrix_char_diagonal (gsl_matrix_char * m); +- +-_gsl_vector_char_view +-gsl_matrix_char_subdiagonal (gsl_matrix_char * m, const size_t k); +- +-_gsl_vector_char_view +-gsl_matrix_char_superdiagonal (gsl_matrix_char * m, const size_t k); +- +-_gsl_vector_char_view +-gsl_matrix_char_subrow (gsl_matrix_char * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_char_view +-gsl_matrix_char_subcolumn (gsl_matrix_char * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_char_view +-gsl_matrix_char_view_array (char * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_char_view +-gsl_matrix_char_view_array_with_tda (char * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_char_view +-gsl_matrix_char_view_vector (gsl_vector_char * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_char_view +-gsl_matrix_char_view_vector_with_tda (gsl_vector_char * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_char_const_view +-gsl_matrix_char_const_submatrix (const gsl_matrix_char * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_row (const gsl_matrix_char * m, +- const size_t i); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_column (const gsl_matrix_char * m, +- const size_t j); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_diagonal (const gsl_matrix_char * m); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_subdiagonal (const gsl_matrix_char * m, +- const size_t k); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_superdiagonal (const gsl_matrix_char * m, +- const size_t k); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_subrow (const gsl_matrix_char * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_char_const_view +-gsl_matrix_char_const_subcolumn (const gsl_matrix_char * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_char_const_view +-gsl_matrix_char_const_view_array (const char * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_char_const_view +-gsl_matrix_char_const_view_array_with_tda (const char * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_char_const_view +-gsl_matrix_char_const_view_vector (const gsl_vector_char * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_char_const_view +-gsl_matrix_char_const_view_vector_with_tda (const gsl_vector_char * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_char_set_zero (gsl_matrix_char * m); +-void gsl_matrix_char_set_identity (gsl_matrix_char * m); +-void gsl_matrix_char_set_all (gsl_matrix_char * m, char x); +- +-int gsl_matrix_char_fread (FILE * stream, gsl_matrix_char * m) ; +-int gsl_matrix_char_fwrite (FILE * stream, const gsl_matrix_char * m) ; +-int gsl_matrix_char_fscanf (FILE * stream, gsl_matrix_char * m); +-int gsl_matrix_char_fprintf (FILE * stream, const gsl_matrix_char * m, const char * format); +- +-int gsl_matrix_char_memcpy(gsl_matrix_char * dest, const gsl_matrix_char * src); +-int gsl_matrix_char_swap(gsl_matrix_char * m1, gsl_matrix_char * m2); +- +-int gsl_matrix_char_swap_rows(gsl_matrix_char * m, const size_t i, const size_t j); +-int gsl_matrix_char_swap_columns(gsl_matrix_char * m, const size_t i, const size_t j); +-int gsl_matrix_char_swap_rowcol(gsl_matrix_char * m, const size_t i, const size_t j); +-int gsl_matrix_char_transpose (gsl_matrix_char * m); +-int gsl_matrix_char_transpose_memcpy (gsl_matrix_char * dest, const gsl_matrix_char * src); +- +-char gsl_matrix_char_max (const gsl_matrix_char * m); +-char gsl_matrix_char_min (const gsl_matrix_char * m); +-void gsl_matrix_char_minmax (const gsl_matrix_char * m, char * min_out, char * max_out); +- +-void gsl_matrix_char_max_index (const gsl_matrix_char * m, size_t * imax, size_t *jmax); +-void gsl_matrix_char_min_index (const gsl_matrix_char * m, size_t * imin, size_t *jmin); +-void gsl_matrix_char_minmax_index (const gsl_matrix_char * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_char_equal (const gsl_matrix_char * a, const gsl_matrix_char * b); +- +-int gsl_matrix_char_isnull (const gsl_matrix_char * m); +-int gsl_matrix_char_ispos (const gsl_matrix_char * m); +-int gsl_matrix_char_isneg (const gsl_matrix_char * m); +-int gsl_matrix_char_isnonneg (const gsl_matrix_char * m); +- +-int gsl_matrix_char_add (gsl_matrix_char * a, const gsl_matrix_char * b); +-int gsl_matrix_char_sub (gsl_matrix_char * a, const gsl_matrix_char * b); +-int gsl_matrix_char_mul_elements (gsl_matrix_char * a, const gsl_matrix_char * b); +-int gsl_matrix_char_div_elements (gsl_matrix_char * a, const gsl_matrix_char * b); +-int gsl_matrix_char_scale (gsl_matrix_char * a, const double x); +-int gsl_matrix_char_add_constant (gsl_matrix_char * a, const double x); +-int gsl_matrix_char_add_diagonal (gsl_matrix_char * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_char_get_row(gsl_vector_char * v, const gsl_matrix_char * m, const size_t i); +-int gsl_matrix_char_get_col(gsl_vector_char * v, const gsl_matrix_char * m, const size_t j); +-int gsl_matrix_char_set_row(gsl_matrix_char * m, const size_t i, const gsl_vector_char * v); +-int gsl_matrix_char_set_col(gsl_matrix_char * m, const size_t j, const gsl_vector_char * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL char gsl_matrix_char_get(const gsl_matrix_char * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_char_set(gsl_matrix_char * m, const size_t i, const size_t j, const char x); +-INLINE_DECL char * gsl_matrix_char_ptr(gsl_matrix_char * m, const size_t i, const size_t j); +-INLINE_DECL const char * gsl_matrix_char_const_ptr(const gsl_matrix_char * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-char +-gsl_matrix_char_get(const gsl_matrix_char * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_char_set(gsl_matrix_char * m, const size_t i, const size_t j, const char x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-char * +-gsl_matrix_char_ptr(gsl_matrix_char * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (char *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const char * +-gsl_matrix_char_const_ptr(const gsl_matrix_char * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const char *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_uint.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_UINT_H__ +-#define __GSL_PERMUTE_VECTOR_UINT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_uint (const gsl_permutation * p, gsl_vector_uint * v); +-int gsl_permute_vector_uint_inverse (const gsl_permutation * p, gsl_vector_uint * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_complex_long_double.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_complex_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ +-#define __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_complex_long_double (const gsl_permutation * p, gsl_vector_complex_long_double * v); +-int gsl_permute_vector_complex_long_double_inverse (const gsl_permutation * p, gsl_vector_complex_long_double * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_int.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_INT_H__ +-#define __GSL_STATISTICS_INT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_int_mean (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_variance (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_sd (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_variance_with_fixed_mean (const int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_int_sd_with_fixed_mean (const int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_int_tss (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_tss_m (const int data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_int_absdev (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_skew (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_kurtosis (const int data[], const size_t stride, const size_t n); +-double gsl_stats_int_lag1_autocorrelation (const int data[], const size_t stride, const size_t n); +- +-double gsl_stats_int_covariance (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n); +-double gsl_stats_int_correlation (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_int_variance_m (const int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_int_sd_m (const int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_int_absdev_m (const int data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_int_skew_m_sd (const int data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_int_kurtosis_m_sd (const int data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_int_lag1_autocorrelation_m (const int data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_int_covariance_m (const int data1[], const size_t stride1,const int data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_int_pvariance (const int data1[], const size_t stride1, const size_t n1, const int data2[], const size_t stride2, const size_t n2); +-double gsl_stats_int_ttest (const int data1[], const size_t stride1, const size_t n1, const int data2[], const size_t stride2, const size_t n2); +- +-int gsl_stats_int_max (const int data[], const size_t stride, const size_t n); +-int gsl_stats_int_min (const int data[], const size_t stride, const size_t n); +-void gsl_stats_int_minmax (int * min, int * max, const int data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_int_max_index (const int data[], const size_t stride, const size_t n); +-size_t gsl_stats_int_min_index (const int data[], const size_t stride, const size_t n); +-void gsl_stats_int_minmax_index (size_t * min_index, size_t * max_index, const int data[], const size_t stride, const size_t n); +- +-double gsl_stats_int_median_from_sorted_data (const int sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_int_quantile_from_sorted_data (const int sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_types.h (revision 14079) +@@ -1,41 +0,0 @@ +-/* gsl_types.h +- * +- * Copyright (C) 2001, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_TYPES_H__ +-#define __GSL_TYPES_H__ +- +-#ifndef GSL_VAR +- +-#ifdef WIN32 +-# ifdef GSL_DLL +-# ifdef DLL_EXPORT +-# define GSL_VAR extern __declspec(dllexport) +-# else +-# define GSL_VAR extern __declspec(dllimport) +-# endif +-# else +-# define GSL_VAR extern +-# endif +-#else +-# define GSL_VAR extern +-#endif +- +-#endif +- +-#endif /* __GSL_TYPES_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_monte_plain.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* monte/gsl_monte_plain.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Plain Monte-Carlo. */ +- +-/* Author: MJB */ +- +-#ifndef __GSL_MONTE_PLAIN_H__ +-#define __GSL_MONTE_PLAIN_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct { +- size_t dim; +- double *x; +-} gsl_monte_plain_state; +- +-int +-gsl_monte_plain_integrate (const gsl_monte_function * f, +- const double xl[], const double xu[], +- const size_t dim, +- const size_t calls, +- gsl_rng * r, +- gsl_monte_plain_state * state, +- double *result, double *abserr); +- +-gsl_monte_plain_state* gsl_monte_plain_alloc(size_t dim); +- +-int gsl_monte_plain_init(gsl_monte_plain_state* state); +- +-void gsl_monte_plain_free (gsl_monte_plain_state* state); +- +-__END_DECLS +- +-#endif /* __GSL_MONTE_PLAIN_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_bessel.h (revision 14079) +@@ -1,549 +0,0 @@ +-/* specfunc/gsl_sf_bessel.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_BESSEL_H__ +-#define __GSL_SF_BESSEL_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Regular Bessel Function J_0(x) +- * +- * exceptions: none +- */ +-int gsl_sf_bessel_J0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_J0(const double x); +- +- +-/* Regular Bessel Function J_1(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_J1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_J1(const double x); +- +- +-/* Regular Bessel Function J_n(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Jn_e(int n, double x, gsl_sf_result * result); +-double gsl_sf_bessel_Jn(const int n, const double x); +- +- +-/* Regular Bessel Function J_n(x), nmin <= n <= nmax +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Jn_array(int nmin, int nmax, double x, double * result_array); +- +- +-/* Irregular Bessel function Y_0(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Y0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Y0(const double x); +- +- +-/* Irregular Bessel function Y_1(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Y1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Y1(const double x); +- +- +-/* Irregular Bessel function Y_n(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Yn_e(int n,const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Yn(const int n,const double x); +- +- +-/* Irregular Bessel function Y_n(x), nmin <= n <= nmax +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Yn_array(const int nmin, const int nmax, const double x, double * result_array); +- +- +-/* Regular modified Bessel function I_0(x) +- * +- * exceptions: GSL_EOVRFLW +- */ +-int gsl_sf_bessel_I0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_I0(const double x); +- +- +-/* Regular modified Bessel function I_1(x) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_I1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_I1(const double x); +- +- +-/* Regular modified Bessel function I_n(x) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_In_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_In(const int n, const double x); +- +- +-/* Regular modified Bessel function I_n(x) for n=nmin,...,nmax +- * +- * nmin >=0, nmax >= nmin +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_In_array(const int nmin, const int nmax, const double x, double * result_array); +- +- +-/* Scaled regular modified Bessel function +- * exp(-|x|) I_0(x) +- * +- * exceptions: none +- */ +-int gsl_sf_bessel_I0_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_I0_scaled(const double x); +- +- +-/* Scaled regular modified Bessel function +- * exp(-|x|) I_1(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_I1_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_I1_scaled(const double x); +- +- +-/* Scaled regular modified Bessel function +- * exp(-|x|) I_n(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_In_scaled_e(int n, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_In_scaled(const int n, const double x); +- +- +-/* Scaled regular modified Bessel function +- * exp(-|x|) I_n(x) for n=nmin,...,nmax +- * +- * nmin >=0, nmax >= nmin +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_In_scaled_array(const int nmin, const int nmax, const double x, double * result_array); +- +- +-/* Irregular modified Bessel function K_0(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_K0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_K0(const double x); +- +- +-/* Irregular modified Bessel function K_1(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_K1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_K1(const double x); +- +- +-/* Irregular modified Bessel function K_n(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Kn_e(const int n, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Kn(const int n, const double x); +- +- +-/* Irregular modified Bessel function K_n(x) for n=nmin,...,nmax +- * +- * x > 0.0, nmin >=0, nmax >= nmin +- * exceptions: GSL_EDOM, GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Kn_array(const int nmin, const int nmax, const double x, double * result_array); +- +- +-/* Scaled irregular modified Bessel function +- * exp(x) K_0(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_bessel_K0_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_K0_scaled(const double x); +- +- +-/* Scaled irregular modified Bessel function +- * exp(x) K_1(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_K1_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_K1_scaled(const double x); +- +- +-/* Scaled irregular modified Bessel function +- * exp(x) K_n(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Kn_scaled_e(int n, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Kn_scaled(const int n, const double x); +- +- +-/* Scaled irregular modified Bessel function exp(x) K_n(x) for n=nmin,...,nmax +- * +- * x > 0.0, nmin >=0, nmax >= nmin +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Kn_scaled_array(const int nmin, const int nmax, const double x, double * result_array); +- +- +-/* Regular spherical Bessel function j_0(x) = sin(x)/x +- * +- * exceptions: none +- */ +-int gsl_sf_bessel_j0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_j0(const double x); +- +- +-/* Regular spherical Bessel function j_1(x) = (sin(x)/x - cos(x))/x +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_j1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_j1(const double x); +- +- +-/* Regular spherical Bessel function j_2(x) = ((3/x^2 - 1)sin(x) - 3cos(x)/x)/x +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_j2_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_j2(const double x); +- +- +-/* Regular spherical Bessel function j_l(x) +- * +- * l >= 0, x >= 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_jl_e(const int l, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_jl(const int l, const double x); +- +- +-/* Regular spherical Bessel function j_l(x) for l=0,1,...,lmax +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_jl_array(const int lmax, const double x, double * result_array); +- +- +-/* Regular spherical Bessel function j_l(x) for l=0,1,...,lmax +- * Uses Steed's method. +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_jl_steed_array(const int lmax, const double x, double * jl_x_array); +- +- +-/* Irregular spherical Bessel function y_0(x) +- * +- * exceptions: none +- */ +-int gsl_sf_bessel_y0_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_y0(const double x); +- +- +-/* Irregular spherical Bessel function y_1(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_y1_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_y1(const double x); +- +- +-/* Irregular spherical Bessel function y_2(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_y2_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_y2(const double x); +- +- +-/* Irregular spherical Bessel function y_l(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_yl_e(int l, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_yl(const int l, const double x); +- +- +-/* Irregular spherical Bessel function y_l(x) for l=0,1,...,lmax +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_yl_array(const int lmax, const double x, double * result_array); +- +- +-/* Regular scaled modified spherical Bessel function +- * +- * Exp[-|x|] i_0(x) +- * +- * exceptions: none +- */ +-int gsl_sf_bessel_i0_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_i0_scaled(const double x); +- +- +-/* Regular scaled modified spherical Bessel function +- * +- * Exp[-|x|] i_1(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_i1_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_i1_scaled(const double x); +- +- +-/* Regular scaled modified spherical Bessel function +- * +- * Exp[-|x|] i_2(x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_i2_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_i2_scaled(const double x); +- +- +-/* Regular scaled modified spherical Bessel functions +- * +- * Exp[-|x|] i_l(x) +- * +- * i_l(x) = Sqrt[Pi/(2x)] BesselI[l+1/2,x] +- * +- * l >= 0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_il_scaled_e(const int l, double x, gsl_sf_result * result); +-double gsl_sf_bessel_il_scaled(const int l, const double x); +- +- +-/* Regular scaled modified spherical Bessel functions +- * +- * Exp[-|x|] i_l(x) +- * for l=0,1,...,lmax +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_il_scaled_array(const int lmax, const double x, double * result_array); +- +- +-/* Irregular scaled modified spherical Bessel function +- * Exp[x] k_0(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_k0_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_k0_scaled(const double x); +- +- +-/* Irregular modified spherical Bessel function +- * Exp[x] k_1(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_bessel_k1_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_k1_scaled(const double x); +- +- +-/* Irregular modified spherical Bessel function +- * Exp[x] k_2(x) +- * +- * x > 0.0 +- * exceptions: GSL_EDOM, GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_bessel_k2_scaled_e(const double x, gsl_sf_result * result); +-double gsl_sf_bessel_k2_scaled(const double x); +- +- +-/* Irregular modified spherical Bessel function +- * Exp[x] k_l[x] +- * +- * k_l(x) = Sqrt[Pi/(2x)] BesselK[l+1/2,x] +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_kl_scaled_e(int l, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_kl_scaled(const int l, const double x); +- +- +-/* Irregular scaled modified spherical Bessel function +- * Exp[x] k_l(x) +- * +- * for l=0,1,...,lmax +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_kl_scaled_array(const int lmax, const double x, double * result_array); +- +- +-/* Regular cylindrical Bessel function J_nu(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Jnu_e(const double nu, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Jnu(const double nu, const double x); +- +- +-/* Irregular cylindrical Bessel function Y_nu(x) +- * +- * exceptions: +- */ +-int gsl_sf_bessel_Ynu_e(double nu, double x, gsl_sf_result * result); +-double gsl_sf_bessel_Ynu(const double nu, const double x); +- +- +-/* Regular cylindrical Bessel function J_nu(x) +- * evaluated at a series of x values. The array +- * contains the x values. They are assumed to be +- * strictly ordered and positive. The array is +- * over-written with the values of J_nu(x_i). +- * +- * exceptions: GSL_EDOM, GSL_EINVAL +- */ +-int gsl_sf_bessel_sequence_Jnu_e(double nu, gsl_mode_t mode, size_t size, double * v); +- +- +-/* Scaled modified cylindrical Bessel functions +- * +- * Exp[-|x|] BesselI[nu, x] +- * x >= 0, nu >= 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_bessel_Inu_scaled_e(double nu, double x, gsl_sf_result * result); +-double gsl_sf_bessel_Inu_scaled(double nu, double x); +- +- +-/* Modified cylindrical Bessel functions +- * +- * BesselI[nu, x] +- * x >= 0, nu >= 0 +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_bessel_Inu_e(double nu, double x, gsl_sf_result * result); +-double gsl_sf_bessel_Inu(double nu, double x); +- +- +-/* Scaled modified cylindrical Bessel functions +- * +- * Exp[+|x|] BesselK[nu, x] +- * x > 0, nu >= 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_bessel_Knu_scaled_e(const double nu, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Knu_scaled(const double nu, const double x); +- +-int gsl_sf_bessel_Knu_scaled_e10_e(const double nu, const double x, gsl_sf_result_e10 * result); +- +-/* Modified cylindrical Bessel functions +- * +- * BesselK[nu, x] +- * x > 0, nu >= 0 +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_bessel_Knu_e(const double nu, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_Knu(const double nu, const double x); +- +- +-/* Logarithm of modified cylindrical Bessel functions. +- * +- * Log[BesselK[nu, x]] +- * x > 0, nu >= 0 +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_bessel_lnKnu_e(const double nu, const double x, gsl_sf_result * result); +-double gsl_sf_bessel_lnKnu(const double nu, const double x); +- +- +-/* s'th positive zero of the Bessel function J_0(x). +- * +- * exceptions: +- */ +-int gsl_sf_bessel_zero_J0_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_bessel_zero_J0(unsigned int s); +- +- +-/* s'th positive zero of the Bessel function J_1(x). +- * +- * exceptions: +- */ +-int gsl_sf_bessel_zero_J1_e(unsigned int s, gsl_sf_result * result); +-double gsl_sf_bessel_zero_J1(unsigned int s); +- +- +-/* s'th positive zero of the Bessel function J_nu(x). +- * +- * exceptions: +- */ +-int gsl_sf_bessel_zero_Jnu_e(double nu, unsigned int s, gsl_sf_result * result); +-double gsl_sf_bessel_zero_Jnu(double nu, unsigned int s); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_BESSEL_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiset.h (revision 14079) +@@ -1,93 +0,0 @@ +-/* multiset/gsl_multiset.h +- * based on combination/gsl_combination.h by Szymon Jaroszewicz +- * based on permutation/gsl_permutation.h by Brian Gough +- * +- * Copyright (C) 2009 Rhys Ulerich +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MULTISET_H__ +-#define __GSL_MULTISET_H__ +- +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_multiset_struct +-{ +- size_t n; +- size_t k; +- size_t *data; +-}; +- +-typedef struct gsl_multiset_struct gsl_multiset; +- +-gsl_multiset *gsl_multiset_alloc (const size_t n, const size_t k); +-gsl_multiset *gsl_multiset_calloc (const size_t n, const size_t k); +-void gsl_multiset_init_first (gsl_multiset * c); +-void gsl_multiset_init_last (gsl_multiset * c); +-void gsl_multiset_free (gsl_multiset * c); +-int gsl_multiset_memcpy (gsl_multiset * dest, const gsl_multiset * src); +- +-int gsl_multiset_fread (FILE * stream, gsl_multiset * c); +-int gsl_multiset_fwrite (FILE * stream, const gsl_multiset * c); +-int gsl_multiset_fscanf (FILE * stream, gsl_multiset * c); +-int gsl_multiset_fprintf (FILE * stream, const gsl_multiset * c, const char *format); +- +-size_t gsl_multiset_n (const gsl_multiset * c); +-size_t gsl_multiset_k (const gsl_multiset * c); +-size_t * gsl_multiset_data (const gsl_multiset * c); +- +-int gsl_multiset_valid (gsl_multiset * c); +-int gsl_multiset_next (gsl_multiset * c); +-int gsl_multiset_prev (gsl_multiset * c); +- +-INLINE_DECL size_t gsl_multiset_get (const gsl_multiset * c, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-size_t +-gsl_multiset_get (const gsl_multiset * c, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= c->k)) /* size_t is unsigned, can't be negative */ +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return c->data[i]; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_MULTISET_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_specfunc.h (revision 14079) +@@ -1,10 +0,0 @@ +-/* Author: G. Jungman */ +- +- +-/* Convenience header */ +-#ifndef __GSL_SPECFUNC_H__ +-#define __GSL_SPECFUNC_H__ +- +-#include +- +-#endif /* __GSL_SPECFUNC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uchar.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_UCHAR_H__ +-#define __GSL_BLOCK_UCHAR_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_uchar_struct +-{ +- size_t size; +- unsigned char *data; +-}; +- +-typedef struct gsl_block_uchar_struct gsl_block_uchar; +- +-gsl_block_uchar *gsl_block_uchar_alloc (const size_t n); +-gsl_block_uchar *gsl_block_uchar_calloc (const size_t n); +-void gsl_block_uchar_free (gsl_block_uchar * b); +- +-int gsl_block_uchar_fread (FILE * stream, gsl_block_uchar * b); +-int gsl_block_uchar_fwrite (FILE * stream, const gsl_block_uchar * b); +-int gsl_block_uchar_fscanf (FILE * stream, gsl_block_uchar * b); +-int gsl_block_uchar_fprintf (FILE * stream, const gsl_block_uchar * b, const char *format); +- +-int gsl_block_uchar_raw_fread (FILE * stream, unsigned char * b, const size_t n, const size_t stride); +-int gsl_block_uchar_raw_fwrite (FILE * stream, const unsigned char * b, const size_t n, const size_t stride); +-int gsl_block_uchar_raw_fscanf (FILE * stream, unsigned char * b, const size_t n, const size_t stride); +-int gsl_block_uchar_raw_fprintf (FILE * stream, const unsigned char * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_uchar_size (const gsl_block_uchar * b); +-unsigned char * gsl_block_uchar_data (const gsl_block_uchar * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_float.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_FLOAT_H__ +-#define __GSL_SORT_FLOAT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_float (float * data, const size_t stride, const size_t n); +-void gsl_sort_float_index (size_t * p, const float * data, const size_t stride, const size_t n); +- +-int gsl_sort_float_smallest (float * dest, const size_t k, const float * src, const size_t stride, const size_t n); +-int gsl_sort_float_smallest_index (size_t * p, const size_t k, const float * src, const size_t stride, const size_t n); +- +-int gsl_sort_float_largest (float * dest, const size_t k, const float * src, const size_t stride, const size_t n); +-int gsl_sort_float_largest_index (size_t * p, const size_t k, const float * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_synchrotron.h (revision 14079) +@@ -1,60 +0,0 @@ +-/* specfunc/gsl_sf_synchrotron.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_SYNCHROTRON_H__ +-#define __GSL_SF_SYNCHROTRON_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* First synchrotron function: +- * synchrotron_1(x) = x Integral[ K_{5/3}(t), {t, x, Infinity}] +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_synchrotron_1_e(const double x, gsl_sf_result * result); +-double gsl_sf_synchrotron_1(const double x); +- +- +-/* Second synchroton function: +- * synchrotron_2(x) = x * K_{2/3}(x) +- * +- * exceptions: GSL_EDOM, GSL_EUNDRFLW +- */ +-int gsl_sf_synchrotron_2_e(const double x, gsl_sf_result * result); +-double gsl_sf_synchrotron_2(const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_SYNCHROTRON_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_complex_math.h (revision 14079) +@@ -1,142 +0,0 @@ +-/* complex/gsl_complex_math.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Jorma Olavi Tähtinen, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_COMPLEX_MATH_H__ +-#define __GSL_COMPLEX_MATH_H__ +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-#define __BEGIN_DECLS extern "C" { +-#define __END_DECLS } +-#else +-#define __BEGIN_DECLS /* empty */ +-#define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Complex numbers */ +- +-gsl_complex gsl_complex_polar (double r, double theta); /* r= r e^(i theta) */ +- +-INLINE_DECL gsl_complex gsl_complex_rect (double x, double y); /* r= real+i*imag */ +- +-#ifdef HAVE_INLINE +-INLINE_FUN gsl_complex +-gsl_complex_rect (double x, double y) +-{ /* return z = x + i y */ +- gsl_complex z; +- GSL_SET_COMPLEX (&z, x, y); +- return z; +-} +-#endif +- +-#define GSL_COMPLEX_ONE (gsl_complex_rect(1.0,0.0)) +-#define GSL_COMPLEX_ZERO (gsl_complex_rect(0.0,0.0)) +-#define GSL_COMPLEX_NEGONE (gsl_complex_rect(-1.0,0.0)) +- +-/* Properties of complex numbers */ +- +-double gsl_complex_arg (gsl_complex z); /* return arg(z), -pi< arg(z) <=+pi */ +-double gsl_complex_abs (gsl_complex z); /* return |z| */ +-double gsl_complex_abs2 (gsl_complex z); /* return |z|^2 */ +-double gsl_complex_logabs (gsl_complex z); /* return log|z| */ +- +-/* Complex arithmetic operators */ +- +-gsl_complex gsl_complex_add (gsl_complex a, gsl_complex b); /* r=a+b */ +-gsl_complex gsl_complex_sub (gsl_complex a, gsl_complex b); /* r=a-b */ +-gsl_complex gsl_complex_mul (gsl_complex a, gsl_complex b); /* r=a*b */ +-gsl_complex gsl_complex_div (gsl_complex a, gsl_complex b); /* r=a/b */ +- +-gsl_complex gsl_complex_add_real (gsl_complex a, double x); /* r=a+x */ +-gsl_complex gsl_complex_sub_real (gsl_complex a, double x); /* r=a-x */ +-gsl_complex gsl_complex_mul_real (gsl_complex a, double x); /* r=a*x */ +-gsl_complex gsl_complex_div_real (gsl_complex a, double x); /* r=a/x */ +- +-gsl_complex gsl_complex_add_imag (gsl_complex a, double y); /* r=a+iy */ +-gsl_complex gsl_complex_sub_imag (gsl_complex a, double y); /* r=a-iy */ +-gsl_complex gsl_complex_mul_imag (gsl_complex a, double y); /* r=a*iy */ +-gsl_complex gsl_complex_div_imag (gsl_complex a, double y); /* r=a/iy */ +- +-gsl_complex gsl_complex_conjugate (gsl_complex z); /* r=conj(z) */ +-gsl_complex gsl_complex_inverse (gsl_complex a); /* r=1/a */ +-gsl_complex gsl_complex_negative (gsl_complex a); /* r=-a */ +- +-/* Elementary Complex Functions */ +- +-gsl_complex gsl_complex_sqrt (gsl_complex z); /* r=sqrt(z) */ +-gsl_complex gsl_complex_sqrt_real (double x); /* r=sqrt(x) (x<0 ok) */ +- +-gsl_complex gsl_complex_pow (gsl_complex a, gsl_complex b); /* r=a^b */ +-gsl_complex gsl_complex_pow_real (gsl_complex a, double b); /* r=a^b */ +- +-gsl_complex gsl_complex_exp (gsl_complex a); /* r=exp(a) */ +-gsl_complex gsl_complex_log (gsl_complex a); /* r=log(a) (base e) */ +-gsl_complex gsl_complex_log10 (gsl_complex a); /* r=log10(a) (base 10) */ +-gsl_complex gsl_complex_log_b (gsl_complex a, gsl_complex b); /* r=log_b(a) (base=b) */ +- +-/* Complex Trigonometric Functions */ +- +-gsl_complex gsl_complex_sin (gsl_complex a); /* r=sin(a) */ +-gsl_complex gsl_complex_cos (gsl_complex a); /* r=cos(a) */ +-gsl_complex gsl_complex_sec (gsl_complex a); /* r=sec(a) */ +-gsl_complex gsl_complex_csc (gsl_complex a); /* r=csc(a) */ +-gsl_complex gsl_complex_tan (gsl_complex a); /* r=tan(a) */ +-gsl_complex gsl_complex_cot (gsl_complex a); /* r=cot(a) */ +- +-/* Inverse Complex Trigonometric Functions */ +- +-gsl_complex gsl_complex_arcsin (gsl_complex a); /* r=arcsin(a) */ +-gsl_complex gsl_complex_arcsin_real (double a); /* r=arcsin(a) */ +-gsl_complex gsl_complex_arccos (gsl_complex a); /* r=arccos(a) */ +-gsl_complex gsl_complex_arccos_real (double a); /* r=arccos(a) */ +-gsl_complex gsl_complex_arcsec (gsl_complex a); /* r=arcsec(a) */ +-gsl_complex gsl_complex_arcsec_real (double a); /* r=arcsec(a) */ +-gsl_complex gsl_complex_arccsc (gsl_complex a); /* r=arccsc(a) */ +-gsl_complex gsl_complex_arccsc_real (double a); /* r=arccsc(a) */ +-gsl_complex gsl_complex_arctan (gsl_complex a); /* r=arctan(a) */ +-gsl_complex gsl_complex_arccot (gsl_complex a); /* r=arccot(a) */ +- +-/* Complex Hyperbolic Functions */ +- +-gsl_complex gsl_complex_sinh (gsl_complex a); /* r=sinh(a) */ +-gsl_complex gsl_complex_cosh (gsl_complex a); /* r=coshh(a) */ +-gsl_complex gsl_complex_sech (gsl_complex a); /* r=sech(a) */ +-gsl_complex gsl_complex_csch (gsl_complex a); /* r=csch(a) */ +-gsl_complex gsl_complex_tanh (gsl_complex a); /* r=tanh(a) */ +-gsl_complex gsl_complex_coth (gsl_complex a); /* r=coth(a) */ +- +-/* Inverse Complex Hyperbolic Functions */ +- +-gsl_complex gsl_complex_arcsinh (gsl_complex a); /* r=arcsinh(a) */ +-gsl_complex gsl_complex_arccosh (gsl_complex a); /* r=arccosh(a) */ +-gsl_complex gsl_complex_arccosh_real (double a); /* r=arccosh(a) */ +-gsl_complex gsl_complex_arcsech (gsl_complex a); /* r=arcsech(a) */ +-gsl_complex gsl_complex_arccsch (gsl_complex a); /* r=arccsch(a) */ +-gsl_complex gsl_complex_arctanh (gsl_complex a); /* r=arctanh(a) */ +-gsl_complex gsl_complex_arctanh_real (double a); /* r=arctanh(a) */ +-gsl_complex gsl_complex_arccoth (gsl_complex a); /* r=arccoth(a) */ +- +-__END_DECLS +- +-#endif /* __GSL_COMPLEX_MATH_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_long.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_LONG_H__ +-#define __GSL_VECTOR_LONG_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- long *data; +- gsl_block_long *block; +- int owner; +-} +-gsl_vector_long; +- +-typedef struct +-{ +- gsl_vector_long vector; +-} _gsl_vector_long_view; +- +-typedef _gsl_vector_long_view gsl_vector_long_view; +- +-typedef struct +-{ +- gsl_vector_long vector; +-} _gsl_vector_long_const_view; +- +-typedef const _gsl_vector_long_const_view gsl_vector_long_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_long *gsl_vector_long_alloc (const size_t n); +-gsl_vector_long *gsl_vector_long_calloc (const size_t n); +- +-gsl_vector_long *gsl_vector_long_alloc_from_block (gsl_block_long * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_long *gsl_vector_long_alloc_from_vector (gsl_vector_long * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_long_free (gsl_vector_long * v); +- +-/* Views */ +- +-_gsl_vector_long_view +-gsl_vector_long_view_array (long *v, size_t n); +- +-_gsl_vector_long_view +-gsl_vector_long_view_array_with_stride (long *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_const_view +-gsl_vector_long_const_view_array (const long *v, size_t n); +- +-_gsl_vector_long_const_view +-gsl_vector_long_const_view_array_with_stride (const long *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_view +-gsl_vector_long_subvector (gsl_vector_long *v, +- size_t i, +- size_t n); +- +-_gsl_vector_long_view +-gsl_vector_long_subvector_with_stride (gsl_vector_long *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_const_view +-gsl_vector_long_const_subvector (const gsl_vector_long *v, +- size_t i, +- size_t n); +- +-_gsl_vector_long_const_view +-gsl_vector_long_const_subvector_with_stride (const gsl_vector_long *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_long_set_zero (gsl_vector_long * v); +-void gsl_vector_long_set_all (gsl_vector_long * v, long x); +-int gsl_vector_long_set_basis (gsl_vector_long * v, size_t i); +- +-int gsl_vector_long_fread (FILE * stream, gsl_vector_long * v); +-int gsl_vector_long_fwrite (FILE * stream, const gsl_vector_long * v); +-int gsl_vector_long_fscanf (FILE * stream, gsl_vector_long * v); +-int gsl_vector_long_fprintf (FILE * stream, const gsl_vector_long * v, +- const char *format); +- +-int gsl_vector_long_memcpy (gsl_vector_long * dest, const gsl_vector_long * src); +- +-int gsl_vector_long_reverse (gsl_vector_long * v); +- +-int gsl_vector_long_swap (gsl_vector_long * v, gsl_vector_long * w); +-int gsl_vector_long_swap_elements (gsl_vector_long * v, const size_t i, const size_t j); +- +-long gsl_vector_long_max (const gsl_vector_long * v); +-long gsl_vector_long_min (const gsl_vector_long * v); +-void gsl_vector_long_minmax (const gsl_vector_long * v, long * min_out, long * max_out); +- +-size_t gsl_vector_long_max_index (const gsl_vector_long * v); +-size_t gsl_vector_long_min_index (const gsl_vector_long * v); +-void gsl_vector_long_minmax_index (const gsl_vector_long * v, size_t * imin, size_t * imax); +- +-int gsl_vector_long_add (gsl_vector_long * a, const gsl_vector_long * b); +-int gsl_vector_long_sub (gsl_vector_long * a, const gsl_vector_long * b); +-int gsl_vector_long_mul (gsl_vector_long * a, const gsl_vector_long * b); +-int gsl_vector_long_div (gsl_vector_long * a, const gsl_vector_long * b); +-int gsl_vector_long_scale (gsl_vector_long * a, const double x); +-int gsl_vector_long_add_constant (gsl_vector_long * a, const double x); +- +-int gsl_vector_long_equal (const gsl_vector_long * u, +- const gsl_vector_long * v); +- +-int gsl_vector_long_isnull (const gsl_vector_long * v); +-int gsl_vector_long_ispos (const gsl_vector_long * v); +-int gsl_vector_long_isneg (const gsl_vector_long * v); +-int gsl_vector_long_isnonneg (const gsl_vector_long * v); +- +-INLINE_DECL long gsl_vector_long_get (const gsl_vector_long * v, const size_t i); +-INLINE_DECL void gsl_vector_long_set (gsl_vector_long * v, const size_t i, long x); +-INLINE_DECL long * gsl_vector_long_ptr (gsl_vector_long * v, const size_t i); +-INLINE_DECL const long * gsl_vector_long_const_ptr (const gsl_vector_long * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-long +-gsl_vector_long_get (const gsl_vector_long * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_long_set (gsl_vector_long * v, const size_t i, long x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-long * +-gsl_vector_long_ptr (gsl_vector_long * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (long *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const long * +-gsl_vector_long_const_ptr (const gsl_vector_long * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const long *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_LONG_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute.h (revision 14079) +@@ -1,24 +0,0 @@ +-#ifndef __GSL_PERMUTE_H__ +-#define __GSL_PERMUTE_H__ +- +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_PERMUTE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_long.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_LONG_H__ +-#define __GSL_PERMUTE_VECTOR_LONG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_long (const gsl_permutation * p, gsl_vector_long * v); +-int gsl_permute_vector_long_inverse (const gsl_permutation * p, gsl_vector_long * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_short.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_SHORT_H__ +-#define __GSL_PERMUTE_VECTOR_SHORT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_short (const gsl_permutation * p, gsl_vector_short * v); +-int gsl_permute_vector_short_inverse (const gsl_permutation * p, gsl_vector_short * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_ushort.h (revision 14079) +@@ -1,44 +0,0 @@ +-/* permutation/gsl_permute_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_USHORT_H__ +-#define __GSL_PERMUTE_USHORT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_ushort (const size_t * p, unsigned short * data, const size_t stride, const size_t n); +-int gsl_permute_ushort_inverse (const size_t * p, unsigned short * data, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_double.h (revision 14079) +@@ -1,351 +0,0 @@ +-/* matrix/gsl_matrix_complex_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_COMPLEX_DOUBLE_H__ +-#define __GSL_MATRIX_COMPLEX_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- double * data; +- gsl_block_complex * block; +- int owner; +-} gsl_matrix_complex ; +- +-typedef struct +-{ +- gsl_matrix_complex matrix; +-} _gsl_matrix_complex_view; +- +-typedef _gsl_matrix_complex_view gsl_matrix_complex_view; +- +-typedef struct +-{ +- gsl_matrix_complex matrix; +-} _gsl_matrix_complex_const_view; +- +-typedef const _gsl_matrix_complex_const_view gsl_matrix_complex_const_view; +- +- +-/* Allocation */ +- +-gsl_matrix_complex * +-gsl_matrix_complex_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex * +-gsl_matrix_complex_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex * +-gsl_matrix_complex_alloc_from_block (gsl_block_complex * b, +- const size_t offset, +- const size_t n1, const size_t n2, const size_t d2); +- +-gsl_matrix_complex * +-gsl_matrix_complex_alloc_from_matrix (gsl_matrix_complex * b, +- const size_t k1, const size_t k2, +- const size_t n1, const size_t n2); +- +-gsl_vector_complex * +-gsl_vector_complex_alloc_row_from_matrix (gsl_matrix_complex * m, +- const size_t i); +- +-gsl_vector_complex * +-gsl_vector_complex_alloc_col_from_matrix (gsl_matrix_complex * m, +- const size_t j); +- +-void gsl_matrix_complex_free (gsl_matrix_complex * m); +- +-/* Views */ +- +-_gsl_matrix_complex_view +-gsl_matrix_complex_submatrix (gsl_matrix_complex * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_row (gsl_matrix_complex * m, const size_t i); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_column (gsl_matrix_complex * m, const size_t j); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_diagonal (gsl_matrix_complex * m); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_subdiagonal (gsl_matrix_complex * m, const size_t k); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_superdiagonal (gsl_matrix_complex * m, const size_t k); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_subrow (gsl_matrix_complex * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_view +-gsl_matrix_complex_subcolumn (gsl_matrix_complex * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_view +-gsl_matrix_complex_view_array (double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_view +-gsl_matrix_complex_view_array_with_tda (double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_view +-gsl_matrix_complex_view_vector (gsl_vector_complex * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_view +-gsl_matrix_complex_view_vector_with_tda (gsl_vector_complex * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_complex_const_view +-gsl_matrix_complex_const_submatrix (const gsl_matrix_complex * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_row (const gsl_matrix_complex * m, +- const size_t i); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_column (const gsl_matrix_complex * m, +- const size_t j); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_diagonal (const gsl_matrix_complex * m); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_subdiagonal (const gsl_matrix_complex * m, +- const size_t k); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_superdiagonal (const gsl_matrix_complex * m, +- const size_t k); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_subrow (const gsl_matrix_complex * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_const_view +-gsl_matrix_complex_const_subcolumn (const gsl_matrix_complex * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_const_view +-gsl_matrix_complex_const_view_array (const double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_const_view +-gsl_matrix_complex_const_view_array_with_tda (const double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_const_view +-gsl_matrix_complex_const_view_vector (const gsl_vector_complex * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_const_view +-gsl_matrix_complex_const_view_vector_with_tda (const gsl_vector_complex * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_complex_set_zero (gsl_matrix_complex * m); +-void gsl_matrix_complex_set_identity (gsl_matrix_complex * m); +-void gsl_matrix_complex_set_all (gsl_matrix_complex * m, gsl_complex x); +- +-int gsl_matrix_complex_fread (FILE * stream, gsl_matrix_complex * m) ; +-int gsl_matrix_complex_fwrite (FILE * stream, const gsl_matrix_complex * m) ; +-int gsl_matrix_complex_fscanf (FILE * stream, gsl_matrix_complex * m); +-int gsl_matrix_complex_fprintf (FILE * stream, const gsl_matrix_complex * m, const char * format); +- +-int gsl_matrix_complex_memcpy(gsl_matrix_complex * dest, const gsl_matrix_complex * src); +-int gsl_matrix_complex_swap(gsl_matrix_complex * m1, gsl_matrix_complex * m2); +- +-int gsl_matrix_complex_swap_rows(gsl_matrix_complex * m, const size_t i, const size_t j); +-int gsl_matrix_complex_swap_columns(gsl_matrix_complex * m, const size_t i, const size_t j); +-int gsl_matrix_complex_swap_rowcol(gsl_matrix_complex * m, const size_t i, const size_t j); +- +-int gsl_matrix_complex_transpose (gsl_matrix_complex * m); +-int gsl_matrix_complex_transpose_memcpy (gsl_matrix_complex * dest, const gsl_matrix_complex * src); +- +-int gsl_matrix_complex_equal (const gsl_matrix_complex * a, const gsl_matrix_complex * b); +- +-int gsl_matrix_complex_isnull (const gsl_matrix_complex * m); +-int gsl_matrix_complex_ispos (const gsl_matrix_complex * m); +-int gsl_matrix_complex_isneg (const gsl_matrix_complex * m); +-int gsl_matrix_complex_isnonneg (const gsl_matrix_complex * m); +- +-int gsl_matrix_complex_add (gsl_matrix_complex * a, const gsl_matrix_complex * b); +-int gsl_matrix_complex_sub (gsl_matrix_complex * a, const gsl_matrix_complex * b); +-int gsl_matrix_complex_mul_elements (gsl_matrix_complex * a, const gsl_matrix_complex * b); +-int gsl_matrix_complex_div_elements (gsl_matrix_complex * a, const gsl_matrix_complex * b); +-int gsl_matrix_complex_scale (gsl_matrix_complex * a, const gsl_complex x); +-int gsl_matrix_complex_add_constant (gsl_matrix_complex * a, const gsl_complex x); +-int gsl_matrix_complex_add_diagonal (gsl_matrix_complex * a, const gsl_complex x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_complex_get_row(gsl_vector_complex * v, const gsl_matrix_complex * m, const size_t i); +-int gsl_matrix_complex_get_col(gsl_vector_complex * v, const gsl_matrix_complex * m, const size_t j); +-int gsl_matrix_complex_set_row(gsl_matrix_complex * m, const size_t i, const gsl_vector_complex * v); +-int gsl_matrix_complex_set_col(gsl_matrix_complex * m, const size_t j, const gsl_vector_complex * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL gsl_complex gsl_matrix_complex_get(const gsl_matrix_complex * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_complex_set(gsl_matrix_complex * m, const size_t i, const size_t j, const gsl_complex x); +- +-INLINE_DECL gsl_complex * gsl_matrix_complex_ptr(gsl_matrix_complex * m, const size_t i, const size_t j); +-INLINE_DECL const gsl_complex * gsl_matrix_complex_const_ptr(const gsl_matrix_complex * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex +-gsl_matrix_complex_get(const gsl_matrix_complex * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- gsl_complex zero = {{0,0}}; +- +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; +- } +- } +-#endif +- return *(gsl_complex *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_complex_set(gsl_matrix_complex * m, +- const size_t i, const size_t j, const gsl_complex x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- *(gsl_complex *)(m->data + 2*(i * m->tda + j)) = x ; +-} +- +-INLINE_FUN +-gsl_complex * +-gsl_matrix_complex_ptr(gsl_matrix_complex * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (gsl_complex *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const gsl_complex * +-gsl_matrix_complex_const_ptr(const gsl_matrix_complex * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const gsl_complex *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_hyperg.h (revision 14079) +@@ -1,154 +0,0 @@ +-/* specfunc/gsl_sf_hyperg.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_HYPERG_H__ +-#define __GSL_SF_HYPERG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Hypergeometric function related to Bessel functions +- * 0F1[c,x] = +- * Gamma[c] x^(1/2(1-c)) I_{c-1}(2 Sqrt[x]) +- * Gamma[c] (-x)^(1/2(1-c)) J_{c-1}(2 Sqrt[-x]) +- * +- * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW +- */ +-int gsl_sf_hyperg_0F1_e(double c, double x, gsl_sf_result * result); +-double gsl_sf_hyperg_0F1(const double c, const double x); +- +- +-/* Confluent hypergeometric function for integer parameters. +- * 1F1[m,n,x] = M(m,n,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_1F1_int_e(const int m, const int n, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_1F1_int(const int m, const int n, double x); +- +- +-/* Confluent hypergeometric function. +- * 1F1[a,b,x] = M(a,b,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_1F1_e(const double a, const double b, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_1F1(double a, double b, double x); +- +- +-/* Confluent hypergeometric function for integer parameters. +- * U(m,n,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_U_int_e(const int m, const int n, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_U_int(const int m, const int n, const double x); +- +- +-/* Confluent hypergeometric function for integer parameters. +- * U(m,n,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_U_int_e10_e(const int m, const int n, const double x, gsl_sf_result_e10 * result); +- +- +-/* Confluent hypergeometric function. +- * U(a,b,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_U_e(const double a, const double b, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_U(const double a, const double b, const double x); +- +- +-/* Confluent hypergeometric function. +- * U(a,b,x) +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_U_e10_e(const double a, const double b, const double x, gsl_sf_result_e10 * result); +- +- +-/* Gauss hypergeometric function 2F1[a,b,c,x] +- * |x| < 1 +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_2F1_e(double a, double b, const double c, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_2F1(double a, double b, double c, double x); +- +- +-/* Gauss hypergeometric function +- * 2F1[aR + I aI, aR - I aI, c, x] +- * |x| < 1 +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_2F1_conj_e(const double aR, const double aI, const double c, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_2F1_conj(double aR, double aI, double c, double x); +- +- +-/* Renormalized Gauss hypergeometric function +- * 2F1[a,b,c,x] / Gamma[c] +- * |x| < 1 +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_2F1_renorm_e(const double a, const double b, const double c, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_2F1_renorm(double a, double b, double c, double x); +- +- +-/* Renormalized Gauss hypergeometric function +- * 2F1[aR + I aI, aR - I aI, c, x] / Gamma[c] +- * |x| < 1 +- * +- * exceptions: +- */ +-int gsl_sf_hyperg_2F1_conj_renorm_e(const double aR, const double aI, const double c, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_2F1_conj_renorm(double aR, double aI, double c, double x); +- +- +-/* Mysterious hypergeometric function. The series representation +- * is a divergent hypergeometric series. However, for x < 0 we +- * have 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x) +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_hyperg_2F0_e(const double a, const double b, const double x, gsl_sf_result * result); +-double gsl_sf_hyperg_2F0(const double a, const double b, const double x); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_HYPERG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_ushort.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_USHORT_H__ +-#define __GSL_SORT_USHORT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_ushort (unsigned short * data, const size_t stride, const size_t n); +-void gsl_sort_ushort_index (size_t * p, const unsigned short * data, const size_t stride, const size_t n); +- +-int gsl_sort_ushort_smallest (unsigned short * dest, const size_t k, const unsigned short * src, const size_t stride, const size_t n); +-int gsl_sort_ushort_smallest_index (size_t * p, const size_t k, const unsigned short * src, const size_t stride, const size_t n); +- +-int gsl_sort_ushort_largest (unsigned short * dest, const size_t k, const unsigned short * src, const size_t stride, const size_t n); +-int gsl_sort_ushort_largest_index (size_t * p, const size_t k, const unsigned short * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_ushort.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_USHORT_H__ +-#define __GSL_STATISTICS_USHORT_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_ushort_mean (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_variance (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_sd (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_variance_with_fixed_mean (const unsigned short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ushort_sd_with_fixed_mean (const unsigned short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ushort_tss (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_tss_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_ushort_absdev (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_skew (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_kurtosis (const unsigned short data[], const size_t stride, const size_t n); +-double gsl_stats_ushort_lag1_autocorrelation (const unsigned short data[], const size_t stride, const size_t n); +- +-double gsl_stats_ushort_covariance (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n); +-double gsl_stats_ushort_correlation (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_ushort_variance_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ushort_sd_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ushort_absdev_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_ushort_skew_m_sd (const unsigned short data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_ushort_kurtosis_m_sd (const unsigned short data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_ushort_lag1_autocorrelation_m (const unsigned short data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_ushort_covariance_m (const unsigned short data1[], const size_t stride1,const unsigned short data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_ushort_pvariance (const unsigned short data1[], const size_t stride1, const size_t n1, const unsigned short data2[], const size_t stride2, const size_t n2); +-double gsl_stats_ushort_ttest (const unsigned short data1[], const size_t stride1, const size_t n1, const unsigned short data2[], const size_t stride2, const size_t n2); +- +-unsigned short gsl_stats_ushort_max (const unsigned short data[], const size_t stride, const size_t n); +-unsigned short gsl_stats_ushort_min (const unsigned short data[], const size_t stride, const size_t n); +-void gsl_stats_ushort_minmax (unsigned short * min, unsigned short * max, const unsigned short data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_ushort_max_index (const unsigned short data[], const size_t stride, const size_t n); +-size_t gsl_stats_ushort_min_index (const unsigned short data[], const size_t stride, const size_t n); +-void gsl_stats_ushort_minmax_index (size_t * min_index, size_t * max_index, const unsigned short data[], const size_t stride, const size_t n); +- +-double gsl_stats_ushort_median_from_sorted_data (const unsigned short sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_ushort_quantile_from_sorted_data (const unsigned short sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_int.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_INT_H__ +-#define __GSL_SORT_INT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_int (int * data, const size_t stride, const size_t n); +-void gsl_sort_int_index (size_t * p, const int * data, const size_t stride, const size_t n); +- +-int gsl_sort_int_smallest (int * dest, const size_t k, const int * src, const size_t stride, const size_t n); +-int gsl_sort_int_smallest_index (size_t * p, const size_t k, const int * src, const size_t stride, const size_t n); +- +-int gsl_sort_int_largest (int * dest, const size_t k, const int * src, const size_t stride, const size_t n); +-int gsl_sort_int_largest_index (size_t * p, const size_t k, const int * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_long_double.h (revision 14079) +@@ -1,251 +0,0 @@ +-/* vector/gsl_vector_complex_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ +-#define __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- long double *data; +- gsl_block_complex_long_double *block; +- int owner; +-} gsl_vector_complex_long_double; +- +-typedef struct +-{ +- gsl_vector_complex_long_double vector; +-} _gsl_vector_complex_long_double_view; +- +-typedef _gsl_vector_complex_long_double_view gsl_vector_complex_long_double_view; +- +-typedef struct +-{ +- gsl_vector_complex_long_double vector; +-} _gsl_vector_complex_long_double_const_view; +- +-typedef const _gsl_vector_complex_long_double_const_view gsl_vector_complex_long_double_const_view; +- +-/* Allocation */ +- +-gsl_vector_complex_long_double *gsl_vector_complex_long_double_alloc (const size_t n); +-gsl_vector_complex_long_double *gsl_vector_complex_long_double_calloc (const size_t n); +- +-gsl_vector_complex_long_double * +-gsl_vector_complex_long_double_alloc_from_block (gsl_block_complex_long_double * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_complex_long_double * +-gsl_vector_complex_long_double_alloc_from_vector (gsl_vector_complex_long_double * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_complex_long_double_free (gsl_vector_complex_long_double * v); +- +-/* Views */ +- +-_gsl_vector_complex_long_double_view +-gsl_vector_complex_long_double_view_array (long double *base, +- size_t n); +- +-_gsl_vector_complex_long_double_view +-gsl_vector_complex_long_double_view_array_with_stride (long double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_long_double_const_view +-gsl_vector_complex_long_double_const_view_array (const long double *base, +- size_t n); +- +-_gsl_vector_complex_long_double_const_view +-gsl_vector_complex_long_double_const_view_array_with_stride (const long double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_long_double_view +-gsl_vector_complex_long_double_subvector (gsl_vector_complex_long_double *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_long_double_view +-gsl_vector_complex_long_double_subvector_with_stride (gsl_vector_complex_long_double *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_long_double_const_view +-gsl_vector_complex_long_double_const_subvector (const gsl_vector_complex_long_double *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_long_double_const_view +-gsl_vector_complex_long_double_const_subvector_with_stride (const gsl_vector_complex_long_double *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_long_double_view +-gsl_vector_complex_long_double_real (gsl_vector_complex_long_double *v); +- +-_gsl_vector_long_double_view +-gsl_vector_complex_long_double_imag (gsl_vector_complex_long_double *v); +- +-_gsl_vector_long_double_const_view +-gsl_vector_complex_long_double_const_real (const gsl_vector_complex_long_double *v); +- +-_gsl_vector_long_double_const_view +-gsl_vector_complex_long_double_const_imag (const gsl_vector_complex_long_double *v); +- +- +-/* Operations */ +- +-void gsl_vector_complex_long_double_set_zero (gsl_vector_complex_long_double * v); +-void gsl_vector_complex_long_double_set_all (gsl_vector_complex_long_double * v, +- gsl_complex_long_double z); +-int gsl_vector_complex_long_double_set_basis (gsl_vector_complex_long_double * v, size_t i); +- +-int gsl_vector_complex_long_double_fread (FILE * stream, +- gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_fwrite (FILE * stream, +- const gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_fscanf (FILE * stream, +- gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_fprintf (FILE * stream, +- const gsl_vector_complex_long_double * v, +- const char *format); +- +-int gsl_vector_complex_long_double_memcpy (gsl_vector_complex_long_double * dest, const gsl_vector_complex_long_double * src); +- +-int gsl_vector_complex_long_double_reverse (gsl_vector_complex_long_double * v); +- +-int gsl_vector_complex_long_double_swap (gsl_vector_complex_long_double * v, gsl_vector_complex_long_double * w); +-int gsl_vector_complex_long_double_swap_elements (gsl_vector_complex_long_double * v, const size_t i, const size_t j); +- +-int gsl_vector_complex_long_double_equal (const gsl_vector_complex_long_double * u, +- const gsl_vector_complex_long_double * v); +- +-int gsl_vector_complex_long_double_isnull (const gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_ispos (const gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_isneg (const gsl_vector_complex_long_double * v); +-int gsl_vector_complex_long_double_isnonneg (const gsl_vector_complex_long_double * v); +- +-int gsl_vector_complex_long_double_add (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); +-int gsl_vector_complex_long_double_sub (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); +-int gsl_vector_complex_long_double_mul (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); +-int gsl_vector_complex_long_double_div (gsl_vector_complex_long_double * a, const gsl_vector_complex_long_double * b); +-int gsl_vector_complex_long_double_scale (gsl_vector_complex_long_double * a, const gsl_complex_long_double x); +-int gsl_vector_complex_long_double_add_constant (gsl_vector_complex_long_double * a, const gsl_complex_long_double x); +- +-INLINE_DECL gsl_complex_long_double gsl_vector_complex_long_double_get (const gsl_vector_complex_long_double * v, const size_t i); +-INLINE_DECL void gsl_vector_complex_long_double_set (gsl_vector_complex_long_double * v, const size_t i, gsl_complex_long_double z); +-INLINE_DECL gsl_complex_long_double *gsl_vector_complex_long_double_ptr (gsl_vector_complex_long_double * v, const size_t i); +-INLINE_DECL const gsl_complex_long_double *gsl_vector_complex_long_double_const_ptr (const gsl_vector_complex_long_double * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex_long_double +-gsl_vector_complex_long_double_get (const gsl_vector_complex_long_double * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- gsl_complex_long_double zero = {{0, 0}}; +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); +- } +-#endif +- return *GSL_COMPLEX_LONG_DOUBLE_AT (v, i); +-} +- +-INLINE_FUN +-void +-gsl_vector_complex_long_double_set (gsl_vector_complex_long_double * v, +- const size_t i, gsl_complex_long_double z) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- *GSL_COMPLEX_LONG_DOUBLE_AT (v, i) = z; +-} +- +-INLINE_FUN +-gsl_complex_long_double * +-gsl_vector_complex_long_double_ptr (gsl_vector_complex_long_double * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_LONG_DOUBLE_AT (v, i); +-} +- +-INLINE_FUN +-const gsl_complex_long_double * +-gsl_vector_complex_long_double_const_ptr (const gsl_vector_complex_long_double * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_LONG_DOUBLE_AT (v, i); +-} +- +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector.h (revision 14079) +@@ -1,24 +0,0 @@ +-#ifndef __GSL_PERMUTE_VECTOR_H__ +-#define __GSL_PERMUTE_VECTOR_H__ +- +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_PERMUTE_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_long_double.h (revision 14079) +@@ -1,99 +0,0 @@ +-/* statistics/gsl_statistics_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_LONG_DOUBLE_H__ +-#define __GSL_STATISTICS_LONG_DOUBLE_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_long_double_mean (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_variance (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_sd (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_variance_with_fixed_mean (const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_sd_with_fixed_mean (const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_tss (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_tss_m (const long double data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_long_double_absdev (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_skew (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_kurtosis (const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_lag1_autocorrelation (const long double data[], const size_t stride, const size_t n); +- +-double gsl_stats_long_double_covariance (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n); +-double gsl_stats_long_double_correlation (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_long_double_variance_m (const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_sd_m (const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_absdev_m (const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_skew_m_sd (const long double data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_long_double_kurtosis_m_sd (const long double data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_long_double_lag1_autocorrelation_m (const long double data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_long_double_covariance_m (const long double data1[], const size_t stride1,const long double data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +-/* DEFINED FOR FLOATING POINT TYPES ONLY */ +- +-double gsl_stats_long_double_wmean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wvariance (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wsd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wvariance_with_fixed_mean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_wsd_with_fixed_mean (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_long_double_wtss (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wtss_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_long_double_wabsdev (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wskew (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +-double gsl_stats_long_double_wkurtosis (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n); +- +-double gsl_stats_long_double_wvariance_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_long_double_wsd_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_long_double_wabsdev_m (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean); +-double gsl_stats_long_double_wskew_m_sd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean, const double wsd); +-double gsl_stats_long_double_wkurtosis_m_sd (const long double w[], const size_t wstride, const long double data[], const size_t stride, const size_t n, const double wmean, const double wsd); +- +-/* END OF FLOATING POINT TYPES */ +- +-double gsl_stats_long_double_pvariance (const long double data1[], const size_t stride1, const size_t n1, const long double data2[], const size_t stride2, const size_t n2); +-double gsl_stats_long_double_ttest (const long double data1[], const size_t stride1, const size_t n1, const long double data2[], const size_t stride2, const size_t n2); +- +-long double gsl_stats_long_double_max (const long double data[], const size_t stride, const size_t n); +-long double gsl_stats_long_double_min (const long double data[], const size_t stride, const size_t n); +-void gsl_stats_long_double_minmax (long double * min, long double * max, const long double data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_long_double_max_index (const long double data[], const size_t stride, const size_t n); +-size_t gsl_stats_long_double_min_index (const long double data[], const size_t stride, const size_t n); +-void gsl_stats_long_double_minmax_index (size_t * min_index, size_t * max_index, const long double data[], const size_t stride, const size_t n); +- +-double gsl_stats_long_double_median_from_sorted_data (const long double sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_long_double_quantile_from_sorted_data (const long double sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_complex_long_double.h (revision 14079) +@@ -1,351 +0,0 @@ +-/* matrix/gsl_matrix_complex_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ +-#define __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- long double * data; +- gsl_block_complex_long_double * block; +- int owner; +-} gsl_matrix_complex_long_double ; +- +-typedef struct +-{ +- gsl_matrix_complex_long_double matrix; +-} _gsl_matrix_complex_long_double_view; +- +-typedef _gsl_matrix_complex_long_double_view gsl_matrix_complex_long_double_view; +- +-typedef struct +-{ +- gsl_matrix_complex_long_double matrix; +-} _gsl_matrix_complex_long_double_const_view; +- +-typedef const _gsl_matrix_complex_long_double_const_view gsl_matrix_complex_long_double_const_view; +- +- +-/* Allocation */ +- +-gsl_matrix_complex_long_double * +-gsl_matrix_complex_long_double_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex_long_double * +-gsl_matrix_complex_long_double_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_complex_long_double * +-gsl_matrix_complex_long_double_alloc_from_block (gsl_block_complex_long_double * b, +- const size_t offset, +- const size_t n1, const size_t n2, const size_t d2); +- +-gsl_matrix_complex_long_double * +-gsl_matrix_complex_long_double_alloc_from_matrix (gsl_matrix_complex_long_double * b, +- const size_t k1, const size_t k2, +- const size_t n1, const size_t n2); +- +-gsl_vector_complex_long_double * +-gsl_vector_complex_long_double_alloc_row_from_matrix (gsl_matrix_complex_long_double * m, +- const size_t i); +- +-gsl_vector_complex_long_double * +-gsl_vector_complex_long_double_alloc_col_from_matrix (gsl_matrix_complex_long_double * m, +- const size_t j); +- +-void gsl_matrix_complex_long_double_free (gsl_matrix_complex_long_double * m); +- +-/* Views */ +- +-_gsl_matrix_complex_long_double_view +-gsl_matrix_complex_long_double_submatrix (gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_row (gsl_matrix_complex_long_double * m, const size_t i); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_column (gsl_matrix_complex_long_double * m, const size_t j); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_diagonal (gsl_matrix_complex_long_double * m); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_subdiagonal (gsl_matrix_complex_long_double * m, const size_t k); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_superdiagonal (gsl_matrix_complex_long_double * m, const size_t k); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_subrow (gsl_matrix_complex_long_double * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_long_double_view +-gsl_matrix_complex_long_double_subcolumn (gsl_matrix_complex_long_double * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_long_double_view +-gsl_matrix_complex_long_double_view_array (long double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_long_double_view +-gsl_matrix_complex_long_double_view_array_with_tda (long double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_long_double_view +-gsl_matrix_complex_long_double_view_vector (gsl_vector_complex_long_double * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_long_double_view +-gsl_matrix_complex_long_double_view_vector_with_tda (gsl_vector_complex_long_double * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_submatrix (const gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_row (const gsl_matrix_complex_long_double * m, +- const size_t i); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_column (const gsl_matrix_complex_long_double * m, +- const size_t j); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_diagonal (const gsl_matrix_complex_long_double * m); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_subdiagonal (const gsl_matrix_complex_long_double * m, +- const size_t k); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_superdiagonal (const gsl_matrix_complex_long_double * m, +- const size_t k); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_subrow (const gsl_matrix_complex_long_double * m, +- const size_t i, const size_t offset, +- const size_t n); +- +-_gsl_vector_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_subcolumn (const gsl_matrix_complex_long_double * m, +- const size_t j, const size_t offset, +- const size_t n); +- +-_gsl_matrix_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_view_array (const long double * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_view_array_with_tda (const long double * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_view_vector (const gsl_vector_complex_long_double * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_complex_long_double_const_view +-gsl_matrix_complex_long_double_const_view_vector_with_tda (const gsl_vector_complex_long_double * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_complex_long_double_set_zero (gsl_matrix_complex_long_double * m); +-void gsl_matrix_complex_long_double_set_identity (gsl_matrix_complex_long_double * m); +-void gsl_matrix_complex_long_double_set_all (gsl_matrix_complex_long_double * m, gsl_complex_long_double x); +- +-int gsl_matrix_complex_long_double_fread (FILE * stream, gsl_matrix_complex_long_double * m) ; +-int gsl_matrix_complex_long_double_fwrite (FILE * stream, const gsl_matrix_complex_long_double * m) ; +-int gsl_matrix_complex_long_double_fscanf (FILE * stream, gsl_matrix_complex_long_double * m); +-int gsl_matrix_complex_long_double_fprintf (FILE * stream, const gsl_matrix_complex_long_double * m, const char * format); +- +-int gsl_matrix_complex_long_double_memcpy(gsl_matrix_complex_long_double * dest, const gsl_matrix_complex_long_double * src); +-int gsl_matrix_complex_long_double_swap(gsl_matrix_complex_long_double * m1, gsl_matrix_complex_long_double * m2); +- +-int gsl_matrix_complex_long_double_swap_rows(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +-int gsl_matrix_complex_long_double_swap_columns(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +-int gsl_matrix_complex_long_double_swap_rowcol(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +- +-int gsl_matrix_complex_long_double_transpose (gsl_matrix_complex_long_double * m); +-int gsl_matrix_complex_long_double_transpose_memcpy (gsl_matrix_complex_long_double * dest, const gsl_matrix_complex_long_double * src); +- +-int gsl_matrix_complex_long_double_equal (const gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); +- +-int gsl_matrix_complex_long_double_isnull (const gsl_matrix_complex_long_double * m); +-int gsl_matrix_complex_long_double_ispos (const gsl_matrix_complex_long_double * m); +-int gsl_matrix_complex_long_double_isneg (const gsl_matrix_complex_long_double * m); +-int gsl_matrix_complex_long_double_isnonneg (const gsl_matrix_complex_long_double * m); +- +-int gsl_matrix_complex_long_double_add (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); +-int gsl_matrix_complex_long_double_sub (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); +-int gsl_matrix_complex_long_double_mul_elements (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); +-int gsl_matrix_complex_long_double_div_elements (gsl_matrix_complex_long_double * a, const gsl_matrix_complex_long_double * b); +-int gsl_matrix_complex_long_double_scale (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); +-int gsl_matrix_complex_long_double_add_constant (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); +-int gsl_matrix_complex_long_double_add_diagonal (gsl_matrix_complex_long_double * a, const gsl_complex_long_double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_complex_long_double_get_row(gsl_vector_complex_long_double * v, const gsl_matrix_complex_long_double * m, const size_t i); +-int gsl_matrix_complex_long_double_get_col(gsl_vector_complex_long_double * v, const gsl_matrix_complex_long_double * m, const size_t j); +-int gsl_matrix_complex_long_double_set_row(gsl_matrix_complex_long_double * m, const size_t i, const gsl_vector_complex_long_double * v); +-int gsl_matrix_complex_long_double_set_col(gsl_matrix_complex_long_double * m, const size_t j, const gsl_vector_complex_long_double * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL gsl_complex_long_double gsl_matrix_complex_long_double_get(const gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_complex_long_double_set(gsl_matrix_complex_long_double * m, const size_t i, const size_t j, const gsl_complex_long_double x); +- +-INLINE_DECL gsl_complex_long_double * gsl_matrix_complex_long_double_ptr(gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +-INLINE_DECL const gsl_complex_long_double * gsl_matrix_complex_long_double_const_ptr(const gsl_matrix_complex_long_double * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex_long_double +-gsl_matrix_complex_long_double_get(const gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- gsl_complex_long_double zero = {{0,0}}; +- +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, zero) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, zero) ; +- } +- } +-#endif +- return *(gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_complex_long_double_set(gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j, const gsl_complex_long_double x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- *(gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) = x ; +-} +- +-INLINE_FUN +-gsl_complex_long_double * +-gsl_matrix_complex_long_double_ptr(gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const gsl_complex_long_double * +-gsl_matrix_complex_long_double_const_ptr(const gsl_matrix_complex_long_double * m, +- const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const gsl_complex_long_double *)(m->data + 2*(i * m->tda + j)) ; +-} +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_COMPLEX_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_blas_types.h (revision 14079) +@@ -1,54 +0,0 @@ +-/* blas/gsl_blas_types.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* +- * Author: G. Jungman +- */ +-/* Based on draft BLAST C interface specification [Jul 7 1998] +- */ +-#ifndef __GSL_BLAS_TYPES_H__ +-#define __GSL_BLAS_TYPES_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef CBLAS_INDEX CBLAS_INDEX_t; +-typedef enum CBLAS_ORDER CBLAS_ORDER_t; +-typedef enum CBLAS_TRANSPOSE CBLAS_TRANSPOSE_t; +-typedef enum CBLAS_UPLO CBLAS_UPLO_t; +-typedef enum CBLAS_DIAG CBLAS_DIAG_t; +-typedef enum CBLAS_SIDE CBLAS_SIDE_t; +- +-/* typedef gsl_complex COMPLEX; */ +- +-__END_DECLS +- +- +-#endif /* __GSL_BLAS_TYPES_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_ulong.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_ULONG_H__ +-#define __GSL_VECTOR_ULONG_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- unsigned long *data; +- gsl_block_ulong *block; +- int owner; +-} +-gsl_vector_ulong; +- +-typedef struct +-{ +- gsl_vector_ulong vector; +-} _gsl_vector_ulong_view; +- +-typedef _gsl_vector_ulong_view gsl_vector_ulong_view; +- +-typedef struct +-{ +- gsl_vector_ulong vector; +-} _gsl_vector_ulong_const_view; +- +-typedef const _gsl_vector_ulong_const_view gsl_vector_ulong_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_ulong *gsl_vector_ulong_alloc (const size_t n); +-gsl_vector_ulong *gsl_vector_ulong_calloc (const size_t n); +- +-gsl_vector_ulong *gsl_vector_ulong_alloc_from_block (gsl_block_ulong * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_ulong *gsl_vector_ulong_alloc_from_vector (gsl_vector_ulong * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_ulong_free (gsl_vector_ulong * v); +- +-/* Views */ +- +-_gsl_vector_ulong_view +-gsl_vector_ulong_view_array (unsigned long *v, size_t n); +- +-_gsl_vector_ulong_view +-gsl_vector_ulong_view_array_with_stride (unsigned long *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_ulong_const_view +-gsl_vector_ulong_const_view_array (const unsigned long *v, size_t n); +- +-_gsl_vector_ulong_const_view +-gsl_vector_ulong_const_view_array_with_stride (const unsigned long *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_ulong_view +-gsl_vector_ulong_subvector (gsl_vector_ulong *v, +- size_t i, +- size_t n); +- +-_gsl_vector_ulong_view +-gsl_vector_ulong_subvector_with_stride (gsl_vector_ulong *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_ulong_const_view +-gsl_vector_ulong_const_subvector (const gsl_vector_ulong *v, +- size_t i, +- size_t n); +- +-_gsl_vector_ulong_const_view +-gsl_vector_ulong_const_subvector_with_stride (const gsl_vector_ulong *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_ulong_set_zero (gsl_vector_ulong * v); +-void gsl_vector_ulong_set_all (gsl_vector_ulong * v, unsigned long x); +-int gsl_vector_ulong_set_basis (gsl_vector_ulong * v, size_t i); +- +-int gsl_vector_ulong_fread (FILE * stream, gsl_vector_ulong * v); +-int gsl_vector_ulong_fwrite (FILE * stream, const gsl_vector_ulong * v); +-int gsl_vector_ulong_fscanf (FILE * stream, gsl_vector_ulong * v); +-int gsl_vector_ulong_fprintf (FILE * stream, const gsl_vector_ulong * v, +- const char *format); +- +-int gsl_vector_ulong_memcpy (gsl_vector_ulong * dest, const gsl_vector_ulong * src); +- +-int gsl_vector_ulong_reverse (gsl_vector_ulong * v); +- +-int gsl_vector_ulong_swap (gsl_vector_ulong * v, gsl_vector_ulong * w); +-int gsl_vector_ulong_swap_elements (gsl_vector_ulong * v, const size_t i, const size_t j); +- +-unsigned long gsl_vector_ulong_max (const gsl_vector_ulong * v); +-unsigned long gsl_vector_ulong_min (const gsl_vector_ulong * v); +-void gsl_vector_ulong_minmax (const gsl_vector_ulong * v, unsigned long * min_out, unsigned long * max_out); +- +-size_t gsl_vector_ulong_max_index (const gsl_vector_ulong * v); +-size_t gsl_vector_ulong_min_index (const gsl_vector_ulong * v); +-void gsl_vector_ulong_minmax_index (const gsl_vector_ulong * v, size_t * imin, size_t * imax); +- +-int gsl_vector_ulong_add (gsl_vector_ulong * a, const gsl_vector_ulong * b); +-int gsl_vector_ulong_sub (gsl_vector_ulong * a, const gsl_vector_ulong * b); +-int gsl_vector_ulong_mul (gsl_vector_ulong * a, const gsl_vector_ulong * b); +-int gsl_vector_ulong_div (gsl_vector_ulong * a, const gsl_vector_ulong * b); +-int gsl_vector_ulong_scale (gsl_vector_ulong * a, const double x); +-int gsl_vector_ulong_add_constant (gsl_vector_ulong * a, const double x); +- +-int gsl_vector_ulong_equal (const gsl_vector_ulong * u, +- const gsl_vector_ulong * v); +- +-int gsl_vector_ulong_isnull (const gsl_vector_ulong * v); +-int gsl_vector_ulong_ispos (const gsl_vector_ulong * v); +-int gsl_vector_ulong_isneg (const gsl_vector_ulong * v); +-int gsl_vector_ulong_isnonneg (const gsl_vector_ulong * v); +- +-INLINE_DECL unsigned long gsl_vector_ulong_get (const gsl_vector_ulong * v, const size_t i); +-INLINE_DECL void gsl_vector_ulong_set (gsl_vector_ulong * v, const size_t i, unsigned long x); +-INLINE_DECL unsigned long * gsl_vector_ulong_ptr (gsl_vector_ulong * v, const size_t i); +-INLINE_DECL const unsigned long * gsl_vector_ulong_const_ptr (const gsl_vector_ulong * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-unsigned long +-gsl_vector_ulong_get (const gsl_vector_ulong * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_ulong_set (gsl_vector_ulong * v, const size_t i, unsigned long x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-unsigned long * +-gsl_vector_ulong_ptr (gsl_vector_ulong * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (unsigned long *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const unsigned long * +-gsl_vector_ulong_const_ptr (const gsl_vector_ulong * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const unsigned long *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_ULONG_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_wavelet.h (revision 14079) +@@ -1,108 +0,0 @@ +-/* wavelet/gsl_wavelet.h +- * +- * Copyright (C) 2004 Ivo Alxneit +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_WAVELET_H__ +-#define __GSL_WAVELET_H__ +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-#ifndef GSL_DISABLE_DEPRECATED +-typedef enum { +- forward = 1, backward = -1, +- gsl_wavelet_forward = 1, gsl_wavelet_backward = -1 +-} +-gsl_wavelet_direction; +-#else +-typedef enum { +- gsl_wavelet_forward = 1, gsl_wavelet_backward = -1 +-} +-gsl_wavelet_direction; +-#endif +- +-typedef struct +-{ +- const char *name; +- int (*init) (const double **h1, const double **g1, +- const double **h2, const double **g2, size_t * nc, +- size_t * offset, size_t member); +-} +-gsl_wavelet_type; +- +-typedef struct +-{ +- const gsl_wavelet_type *type; +- const double *h1; +- const double *g1; +- const double *h2; +- const double *g2; +- size_t nc; +- size_t offset; +-} +-gsl_wavelet; +- +-typedef struct +-{ +- double *scratch; +- size_t n; +-} +-gsl_wavelet_workspace; +- +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_daubechies; +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_daubechies_centered; +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_haar; +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_haar_centered; +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_bspline; +-GSL_VAR const gsl_wavelet_type *gsl_wavelet_bspline_centered; +- +-gsl_wavelet *gsl_wavelet_alloc (const gsl_wavelet_type * T, size_t k); +-void gsl_wavelet_free (gsl_wavelet * w); +-const char *gsl_wavelet_name (const gsl_wavelet * w); +- +-gsl_wavelet_workspace *gsl_wavelet_workspace_alloc (size_t n); +-void gsl_wavelet_workspace_free (gsl_wavelet_workspace * work); +- +-int gsl_wavelet_transform (const gsl_wavelet * w, +- double *data, size_t stride, size_t n, +- gsl_wavelet_direction dir, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet_transform_forward (const gsl_wavelet * w, +- double *data, size_t stride, size_t n, +- gsl_wavelet_workspace * work); +- +-int gsl_wavelet_transform_inverse (const gsl_wavelet * w, +- double *data, size_t stride, size_t n, +- gsl_wavelet_workspace * work); +- +-__END_DECLS +- +-#endif /* __GSL_WAVELET_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_coupling.h (revision 14079) +@@ -1,125 +0,0 @@ +-/* specfunc/gsl_sf_coupling.h +- * +- * Copyright (C) 1996,1997,1998,1999,2000,2001,2002 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_COUPLING_H__ +-#define __GSL_SF_COUPLING_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* 3j Symbols: / ja jb jc \ +- * \ ma mb mc / +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_coupling_3j_e(int two_ja, int two_jb, int two_jc, +- int two_ma, int two_mb, int two_mc, +- gsl_sf_result * result +- ); +-double gsl_sf_coupling_3j(int two_ja, int two_jb, int two_jc, +- int two_ma, int two_mb, int two_mc +- ); +- +- +-/* 6j Symbols: / ja jb jc \ +- * \ jd je jf / +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_coupling_6j_e(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf, +- gsl_sf_result * result +- ); +-double gsl_sf_coupling_6j(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf +- ); +- +-/* Racah W coefficients: +- * +- * W(a b c d; e f) = (-1)^{a+b+c+d} / a b e \ +- * \ d c f / +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_coupling_RacahW_e(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf, +- gsl_sf_result * result +- ); +-double gsl_sf_coupling_RacahW(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf +- ); +- +- +-/* 9j Symbols: / ja jb jc \ +- * | jd je jf | +- * \ jg jh ji / +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-int gsl_sf_coupling_9j_e(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf, +- int two_jg, int two_jh, int two_ji, +- gsl_sf_result * result +- ); +-double gsl_sf_coupling_9j(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf, +- int two_jg, int two_jh, int two_ji +- ); +- +- +-/* INCORRECT version of 6j Symbols: +- * This function actually calculates +- * / ja jb je \ +- * \ jd jc jf / +- * It represents the original implementation, +- * which had the above permutation of the +- * arguments. This was wrong and confusing, +- * and I had to fix it. Sorry for the trouble. +- * [GJ] Tue Nov 26 12:53:39 MST 2002 +- * +- * exceptions: GSL_EDOM, GSL_EOVRFLW +- */ +-#ifndef GSL_DISABLE_DEPRECATED +-int gsl_sf_coupling_6j_INCORRECT_e(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf, +- gsl_sf_result * result +- ); +-double gsl_sf_coupling_6j_INCORRECT(int two_ja, int two_jb, int two_jc, +- int two_jd, int two_je, int two_jf +- ); +-#endif /* !GSL_DISABLE_DEPRECATED */ +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_COUPLING_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf.h (revision 14079) +@@ -1,39 +0,0 @@ +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_H__ +-#define __GSL_SF_H__ +- +-#include +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +- +-#endif /* __GSL_SF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector.h (revision 14079) +@@ -1,20 +0,0 @@ +-#ifndef __GSL_SORT_VECTOR_H__ +-#define __GSL_SORT_VECTOR_H__ +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_SORT_VECTOR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_short.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_short.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_SHORT_H__ +-#define __GSL_BLOCK_SHORT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_short_struct +-{ +- size_t size; +- short *data; +-}; +- +-typedef struct gsl_block_short_struct gsl_block_short; +- +-gsl_block_short *gsl_block_short_alloc (const size_t n); +-gsl_block_short *gsl_block_short_calloc (const size_t n); +-void gsl_block_short_free (gsl_block_short * b); +- +-int gsl_block_short_fread (FILE * stream, gsl_block_short * b); +-int gsl_block_short_fwrite (FILE * stream, const gsl_block_short * b); +-int gsl_block_short_fscanf (FILE * stream, gsl_block_short * b); +-int gsl_block_short_fprintf (FILE * stream, const gsl_block_short * b, const char *format); +- +-int gsl_block_short_raw_fread (FILE * stream, short * b, const size_t n, const size_t stride); +-int gsl_block_short_raw_fwrite (FILE * stream, const short * b, const size_t n, const size_t stride); +-int gsl_block_short_raw_fscanf (FILE * stream, short * b, const size_t n, const size_t stride); +-int gsl_block_short_raw_fprintf (FILE * stream, const short * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_short_size (const gsl_block_short * b); +-short * gsl_block_short_data (const gsl_block_short * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_SHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_vector_ushort.h (revision 14079) +@@ -1,51 +0,0 @@ +-/* sort/gsl_sort_vector_ushort.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_VECTOR_USHORT_H__ +-#define __GSL_SORT_VECTOR_USHORT_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_vector_ushort (gsl_vector_ushort * v); +-int gsl_sort_vector_ushort_index (gsl_permutation * p, const gsl_vector_ushort * v); +- +-int gsl_sort_vector_ushort_smallest (unsigned short * dest, const size_t k, const gsl_vector_ushort * v); +-int gsl_sort_vector_ushort_largest (unsigned short * dest, const size_t k, const gsl_vector_ushort * v); +- +-int gsl_sort_vector_ushort_smallest_index (size_t * p, const size_t k, const gsl_vector_ushort * v); +-int gsl_sort_vector_ushort_largest_index (size_t * p, const size_t k, const gsl_vector_ushort * v); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_VECTOR_USHORT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_multiroots.h (revision 14079) +@@ -1,177 +0,0 @@ +-/* multiroots/gsl_multiroots.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MULTIROOTS_H__ +-#define __GSL_MULTIROOTS_H__ +- +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Definition of vector-valued functions with parameters based on gsl_vector */ +- +-struct gsl_multiroot_function_struct +-{ +- int (* f) (const gsl_vector * x, void * params, gsl_vector * f); +- size_t n; +- void * params; +-}; +- +-typedef struct gsl_multiroot_function_struct gsl_multiroot_function ; +- +-#define GSL_MULTIROOT_FN_EVAL(F,x,y) (*((F)->f))(x,(F)->params,(y)) +- +-int gsl_multiroot_fdjacobian (gsl_multiroot_function * F, +- const gsl_vector * x, const gsl_vector * f, +- double epsrel, gsl_matrix * jacobian); +- +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n); +- int (*set) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); +- int (*iterate) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx); +- void (*free) (void *state); +- } +-gsl_multiroot_fsolver_type; +- +-typedef struct +- { +- const gsl_multiroot_fsolver_type * type; +- gsl_multiroot_function * function ; +- gsl_vector * x ; +- gsl_vector * f ; +- gsl_vector * dx ; +- void *state; +- } +-gsl_multiroot_fsolver; +- +-gsl_multiroot_fsolver * +-gsl_multiroot_fsolver_alloc (const gsl_multiroot_fsolver_type * T, +- size_t n); +- +-void gsl_multiroot_fsolver_free (gsl_multiroot_fsolver * s); +- +-int gsl_multiroot_fsolver_set (gsl_multiroot_fsolver * s, +- gsl_multiroot_function * f, +- const gsl_vector * x); +- +-int gsl_multiroot_fsolver_iterate (gsl_multiroot_fsolver * s); +- +-const char * gsl_multiroot_fsolver_name (const gsl_multiroot_fsolver * s); +-gsl_vector * gsl_multiroot_fsolver_root (const gsl_multiroot_fsolver * s); +-gsl_vector * gsl_multiroot_fsolver_dx (const gsl_multiroot_fsolver * s); +-gsl_vector * gsl_multiroot_fsolver_f (const gsl_multiroot_fsolver * s); +- +-/* Definition of vector-valued functions and gradient with parameters +- based on gsl_vector */ +- +-struct gsl_multiroot_function_fdf_struct +-{ +- int (* f) (const gsl_vector * x, void * params, gsl_vector * f); +- int (* df) (const gsl_vector * x, void * params, gsl_matrix * df); +- int (* fdf) (const gsl_vector * x, void * params, gsl_vector * f, gsl_matrix *df); +- size_t n; +- void * params; +-}; +- +-typedef struct gsl_multiroot_function_fdf_struct gsl_multiroot_function_fdf ; +- +-#define GSL_MULTIROOT_FN_EVAL_F(F,x,y) ((*((F)->f))(x,(F)->params,(y))) +-#define GSL_MULTIROOT_FN_EVAL_DF(F,x,dy) ((*((F)->df))(x,(F)->params,(dy))) +-#define GSL_MULTIROOT_FN_EVAL_F_DF(F,x,y,dy) ((*((F)->fdf))(x,(F)->params,(y),(dy))) +- +-typedef struct +- { +- const char *name; +- size_t size; +- int (*alloc) (void *state, size_t n); +- int (*set) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); +- int (*iterate) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx); +- void (*free) (void *state); +- } +-gsl_multiroot_fdfsolver_type; +- +-typedef struct +- { +- const gsl_multiroot_fdfsolver_type * type; +- gsl_multiroot_function_fdf * fdf ; +- gsl_vector * x; +- gsl_vector * f; +- gsl_matrix * J; +- gsl_vector * dx; +- void *state; +- } +-gsl_multiroot_fdfsolver; +- +-gsl_multiroot_fdfsolver * +-gsl_multiroot_fdfsolver_alloc (const gsl_multiroot_fdfsolver_type * T, +- size_t n); +- +-int +-gsl_multiroot_fdfsolver_set (gsl_multiroot_fdfsolver * s, +- gsl_multiroot_function_fdf * fdf, +- const gsl_vector * x); +- +-int +-gsl_multiroot_fdfsolver_iterate (gsl_multiroot_fdfsolver * s); +- +-void +-gsl_multiroot_fdfsolver_free (gsl_multiroot_fdfsolver * s); +- +-const char * gsl_multiroot_fdfsolver_name (const gsl_multiroot_fdfsolver * s); +-gsl_vector * gsl_multiroot_fdfsolver_root (const gsl_multiroot_fdfsolver * s); +-gsl_vector * gsl_multiroot_fdfsolver_dx (const gsl_multiroot_fdfsolver * s); +-gsl_vector * gsl_multiroot_fdfsolver_f (const gsl_multiroot_fdfsolver * s); +- +-int gsl_multiroot_test_delta (const gsl_vector * dx, const gsl_vector * x, +- double epsabs, double epsrel); +- +-int gsl_multiroot_test_residual (const gsl_vector * f, double epsabs); +- +-GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_dnewton; +-GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_broyden; +-GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrid; +-GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrids; +- +-GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_newton; +-GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_gnewton; +-GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridj; +-GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridsj; +- +- +-__END_DECLS +- +-#endif /* __GSL_MULTIROOTS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_elljac.h (revision 14079) +@@ -1,48 +0,0 @@ +-/* specfunc/gsl_sf_elljac.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_ELLJAC_H__ +-#define __GSL_SF_ELLJAC_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Jacobian elliptic functions sn, dn, cn, +- * by descending Landen transformations +- * +- * exceptions: GSL_EDOM +- */ +-int gsl_sf_elljac_e(double u, double m, double * sn, double * cn, double * dn); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_ELLJAC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_cblas.h (revision 14079) +@@ -1,606 +0,0 @@ +-/* blas/gsl_cblas.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* This is a copy of the CBLAS standard header. +- * We carry this around so we do not have to +- * break our model for flexible BLAS functionality. +- */ +- +-#ifndef __GSL_CBLAS_H__ +-#define __GSL_CBLAS_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-#define __BEGIN_DECLS extern "C" { +-#define __END_DECLS } +-#else +-#define __BEGIN_DECLS /* empty */ +-#define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* +- * Enumerated and derived types +- */ +-#define CBLAS_INDEX size_t /* this may vary between platforms */ +- +-enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102}; +-enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113}; +-enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}; +-enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}; +-enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; +- +-/* +- * =========================================================================== +- * Prototypes for level 1 BLAS functions (complex are recast as routines) +- * =========================================================================== +- */ +-float cblas_sdsdot(const int N, const float alpha, const float *X, +- const int incX, const float *Y, const int incY); +-double cblas_dsdot(const int N, const float *X, const int incX, const float *Y, +- const int incY); +-float cblas_sdot(const int N, const float *X, const int incX, +- const float *Y, const int incY); +-double cblas_ddot(const int N, const double *X, const int incX, +- const double *Y, const int incY); +- +-/* +- * Functions having prefixes Z and C only +- */ +-void cblas_cdotu_sub(const int N, const void *X, const int incX, +- const void *Y, const int incY, void *dotu); +-void cblas_cdotc_sub(const int N, const void *X, const int incX, +- const void *Y, const int incY, void *dotc); +- +-void cblas_zdotu_sub(const int N, const void *X, const int incX, +- const void *Y, const int incY, void *dotu); +-void cblas_zdotc_sub(const int N, const void *X, const int incX, +- const void *Y, const int incY, void *dotc); +- +- +-/* +- * Functions having prefixes S D SC DZ +- */ +-float cblas_snrm2(const int N, const float *X, const int incX); +-float cblas_sasum(const int N, const float *X, const int incX); +- +-double cblas_dnrm2(const int N, const double *X, const int incX); +-double cblas_dasum(const int N, const double *X, const int incX); +- +-float cblas_scnrm2(const int N, const void *X, const int incX); +-float cblas_scasum(const int N, const void *X, const int incX); +- +-double cblas_dznrm2(const int N, const void *X, const int incX); +-double cblas_dzasum(const int N, const void *X, const int incX); +- +- +-/* +- * Functions having standard 4 prefixes (S D C Z) +- */ +-CBLAS_INDEX cblas_isamax(const int N, const float *X, const int incX); +-CBLAS_INDEX cblas_idamax(const int N, const double *X, const int incX); +-CBLAS_INDEX cblas_icamax(const int N, const void *X, const int incX); +-CBLAS_INDEX cblas_izamax(const int N, const void *X, const int incX); +- +-/* +- * =========================================================================== +- * Prototypes for level 1 BLAS routines +- * =========================================================================== +- */ +- +-/* +- * Routines with standard 4 prefixes (s, d, c, z) +- */ +-void cblas_sswap(const int N, float *X, const int incX, +- float *Y, const int incY); +-void cblas_scopy(const int N, const float *X, const int incX, +- float *Y, const int incY); +-void cblas_saxpy(const int N, const float alpha, const float *X, +- const int incX, float *Y, const int incY); +- +-void cblas_dswap(const int N, double *X, const int incX, +- double *Y, const int incY); +-void cblas_dcopy(const int N, const double *X, const int incX, +- double *Y, const int incY); +-void cblas_daxpy(const int N, const double alpha, const double *X, +- const int incX, double *Y, const int incY); +- +-void cblas_cswap(const int N, void *X, const int incX, +- void *Y, const int incY); +-void cblas_ccopy(const int N, const void *X, const int incX, +- void *Y, const int incY); +-void cblas_caxpy(const int N, const void *alpha, const void *X, +- const int incX, void *Y, const int incY); +- +-void cblas_zswap(const int N, void *X, const int incX, +- void *Y, const int incY); +-void cblas_zcopy(const int N, const void *X, const int incX, +- void *Y, const int incY); +-void cblas_zaxpy(const int N, const void *alpha, const void *X, +- const int incX, void *Y, const int incY); +- +- +-/* +- * Routines with S and D prefix only +- */ +-void cblas_srotg(float *a, float *b, float *c, float *s); +-void cblas_srotmg(float *d1, float *d2, float *b1, const float b2, float *P); +-void cblas_srot(const int N, float *X, const int incX, +- float *Y, const int incY, const float c, const float s); +-void cblas_srotm(const int N, float *X, const int incX, +- float *Y, const int incY, const float *P); +- +-void cblas_drotg(double *a, double *b, double *c, double *s); +-void cblas_drotmg(double *d1, double *d2, double *b1, const double b2, double *P); +-void cblas_drot(const int N, double *X, const int incX, +- double *Y, const int incY, const double c, const double s); +-void cblas_drotm(const int N, double *X, const int incX, +- double *Y, const int incY, const double *P); +- +- +-/* +- * Routines with S D C Z CS and ZD prefixes +- */ +-void cblas_sscal(const int N, const float alpha, float *X, const int incX); +-void cblas_dscal(const int N, const double alpha, double *X, const int incX); +-void cblas_cscal(const int N, const void *alpha, void *X, const int incX); +-void cblas_zscal(const int N, const void *alpha, void *X, const int incX); +-void cblas_csscal(const int N, const float alpha, void *X, const int incX); +-void cblas_zdscal(const int N, const double alpha, void *X, const int incX); +- +-/* +- * =========================================================================== +- * Prototypes for level 2 BLAS +- * =========================================================================== +- */ +- +-/* +- * Routines with standard 4 prefixes (S, D, C, Z) +- */ +-void cblas_sgemv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const float alpha, const float *A, const int lda, +- const float *X, const int incX, const float beta, +- float *Y, const int incY); +-void cblas_sgbmv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const int KL, const int KU, const float alpha, +- const float *A, const int lda, const float *X, +- const int incX, const float beta, float *Y, const int incY); +-void cblas_strmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const float *A, const int lda, +- float *X, const int incX); +-void cblas_stbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const float *A, const int lda, +- float *X, const int incX); +-void cblas_stpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const float *Ap, float *X, const int incX); +-void cblas_strsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const float *A, const int lda, float *X, +- const int incX); +-void cblas_stbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const float *A, const int lda, +- float *X, const int incX); +-void cblas_stpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const float *Ap, float *X, const int incX); +- +-void cblas_dgemv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const double alpha, const double *A, const int lda, +- const double *X, const int incX, const double beta, +- double *Y, const int incY); +-void cblas_dgbmv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const int KL, const int KU, const double alpha, +- const double *A, const int lda, const double *X, +- const int incX, const double beta, double *Y, const int incY); +-void cblas_dtrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const double *A, const int lda, +- double *X, const int incX); +-void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const double *A, const int lda, +- double *X, const int incX); +-void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const double *Ap, double *X, const int incX); +-void cblas_dtrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const double *A, const int lda, double *X, +- const int incX); +-void cblas_dtbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const double *A, const int lda, +- double *X, const int incX); +-void cblas_dtpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const double *Ap, double *X, const int incX); +- +-void cblas_cgemv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *X, const int incX, const void *beta, +- void *Y, const int incY); +-void cblas_cgbmv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const int KL, const int KU, const void *alpha, +- const void *A, const int lda, const void *X, +- const int incX, const void *beta, void *Y, const int incY); +-void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *Ap, void *X, const int incX); +-void cblas_ctrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *A, const int lda, void *X, +- const int incX); +-void cblas_ctbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ctpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *Ap, void *X, const int incX); +- +-void cblas_zgemv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *X, const int incX, const void *beta, +- void *Y, const int incY); +-void cblas_zgbmv(const enum CBLAS_ORDER order, +- const enum CBLAS_TRANSPOSE TransA, const int M, const int N, +- const int KL, const int KU, const void *alpha, +- const void *A, const int lda, const void *X, +- const int incX, const void *beta, void *Y, const int incY); +-void cblas_ztrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ztbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ztpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *Ap, void *X, const int incX); +-void cblas_ztrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *A, const int lda, void *X, +- const int incX); +-void cblas_ztbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const int K, const void *A, const int lda, +- void *X, const int incX); +-void cblas_ztpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, +- const int N, const void *Ap, void *X, const int incX); +- +- +-/* +- * Routines with S and D prefixes only +- */ +-void cblas_ssymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *A, +- const int lda, const float *X, const int incX, +- const float beta, float *Y, const int incY); +-void cblas_ssbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const int K, const float alpha, const float *A, +- const int lda, const float *X, const int incX, +- const float beta, float *Y, const int incY); +-void cblas_sspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *Ap, +- const float *X, const int incX, +- const float beta, float *Y, const int incY); +-void cblas_sger(const enum CBLAS_ORDER order, const int M, const int N, +- const float alpha, const float *X, const int incX, +- const float *Y, const int incY, float *A, const int lda); +-void cblas_ssyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *X, +- const int incX, float *A, const int lda); +-void cblas_sspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *X, +- const int incX, float *Ap); +-void cblas_ssyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *X, +- const int incX, const float *Y, const int incY, float *A, +- const int lda); +-void cblas_sspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const float *X, +- const int incX, const float *Y, const int incY, float *A); +- +-void cblas_dsymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *A, +- const int lda, const double *X, const int incX, +- const double beta, double *Y, const int incY); +-void cblas_dsbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const int K, const double alpha, const double *A, +- const int lda, const double *X, const int incX, +- const double beta, double *Y, const int incY); +-void cblas_dspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *Ap, +- const double *X, const int incX, +- const double beta, double *Y, const int incY); +-void cblas_dger(const enum CBLAS_ORDER order, const int M, const int N, +- const double alpha, const double *X, const int incX, +- const double *Y, const int incY, double *A, const int lda); +-void cblas_dsyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *X, +- const int incX, double *A, const int lda); +-void cblas_dspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *X, +- const int incX, double *Ap); +-void cblas_dsyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *X, +- const int incX, const double *Y, const int incY, double *A, +- const int lda); +-void cblas_dspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const double *X, +- const int incX, const double *Y, const int incY, double *A); +- +- +-/* +- * Routines with C and Z prefixes only +- */ +-void cblas_chemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const void *alpha, const void *A, +- const int lda, const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_chbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const int K, const void *alpha, const void *A, +- const int lda, const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_chpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const void *alpha, const void *Ap, +- const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const void *X, const int incX, +- void *A, const int lda); +-void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const float alpha, const void *X, +- const int incX, void *A); +-void cblas_cher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_chpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *Ap); +- +-void cblas_zhemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const void *alpha, const void *A, +- const int lda, const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_zhbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const int K, const void *alpha, const void *A, +- const int lda, const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_zhpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const void *alpha, const void *Ap, +- const void *X, const int incX, +- const void *beta, void *Y, const int incY); +-void cblas_zgeru(const enum CBLAS_ORDER order, const int M, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_zgerc(const enum CBLAS_ORDER order, const int M, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_zher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const void *X, const int incX, +- void *A, const int lda); +-void cblas_zhpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, +- const int N, const double alpha, const void *X, +- const int incX, void *A); +-void cblas_zher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *A, const int lda); +-void cblas_zhpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, +- const void *alpha, const void *X, const int incX, +- const void *Y, const int incY, void *Ap); +- +-/* +- * =========================================================================== +- * Prototypes for level 3 BLAS +- * =========================================================================== +- */ +- +-/* +- * Routines with standard 4 prefixes (S, D, C, Z) +- */ +-void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_TRANSPOSE TransB, const int M, const int N, +- const int K, const float alpha, const float *A, +- const int lda, const float *B, const int ldb, +- const float beta, float *C, const int ldc); +-void cblas_ssymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const float alpha, const float *A, const int lda, +- const float *B, const int ldb, const float beta, +- float *C, const int ldc); +-void cblas_ssyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const float alpha, const float *A, const int lda, +- const float beta, float *C, const int ldc); +-void cblas_ssyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const float alpha, const float *A, const int lda, +- const float *B, const int ldb, const float beta, +- float *C, const int ldc); +-void cblas_strmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const float alpha, const float *A, const int lda, +- float *B, const int ldb); +-void cblas_strsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const float alpha, const float *A, const int lda, +- float *B, const int ldb); +- +-void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_TRANSPOSE TransB, const int M, const int N, +- const int K, const double alpha, const double *A, +- const int lda, const double *B, const int ldb, +- const double beta, double *C, const int ldc); +-void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const double alpha, const double *A, const int lda, +- const double *B, const int ldb, const double beta, +- double *C, const int ldc); +-void cblas_dsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const double alpha, const double *A, const int lda, +- const double beta, double *C, const int ldc); +-void cblas_dsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const double alpha, const double *A, const int lda, +- const double *B, const int ldb, const double beta, +- double *C, const int ldc); +-void cblas_dtrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const double alpha, const double *A, const int lda, +- double *B, const int ldb); +-void cblas_dtrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const double alpha, const double *A, const int lda, +- double *B, const int ldb); +- +-void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_TRANSPOSE TransB, const int M, const int N, +- const int K, const void *alpha, const void *A, +- const int lda, const void *B, const int ldb, +- const void *beta, void *C, const int ldc); +-void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *beta, void *C, const int ldc); +-void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- void *B, const int ldb); +-void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- void *B, const int ldb); +- +-void cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_TRANSPOSE TransB, const int M, const int N, +- const int K, const void *alpha, const void *A, +- const int lda, const void *B, const int ldb, +- const void *beta, void *C, const int ldc); +-void cblas_zsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_zsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *beta, void *C, const int ldc); +-void cblas_zsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_ztrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- void *B, const int ldb); +-void cblas_ztrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, +- const enum CBLAS_DIAG Diag, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- void *B, const int ldb); +- +- +-/* +- * Routines with prefixes C and Z only +- */ +-void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const float alpha, const void *A, const int lda, +- const float beta, void *C, const int ldc); +-void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const float beta, +- void *C, const int ldc); +- +-void cblas_zhemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, +- const enum CBLAS_UPLO Uplo, const int M, const int N, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const void *beta, +- void *C, const int ldc); +-void cblas_zherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const double alpha, const void *A, const int lda, +- const double beta, void *C, const int ldc); +-void cblas_zher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, +- const enum CBLAS_TRANSPOSE Trans, const int N, const int K, +- const void *alpha, const void *A, const int lda, +- const void *B, const int ldb, const double beta, +- void *C, const int ldc); +- +-void cblas_xerbla(int p, const char *rout, const char *form, ...); +- +-__END_DECLS +- +-#endif /* __GSL_CBLAS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_version.h (revision 14079) +@@ -1,26 +0,0 @@ +-#ifndef __GSL_VERSION_H__ +-#define __GSL_VERSION_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +-__BEGIN_DECLS +- +- +-#define GSL_VERSION "1.15" +-#define GSL_MAJOR_VERSION 1 +-#define GSL_MINOR_VERSION 15 +- +-GSL_VAR const char * gsl_version; +- +-__END_DECLS +- +-#endif /* __GSL_VERSION_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_halfcomplex_float.h (revision 14079) +@@ -1,86 +0,0 @@ +-/* fft/gsl_fft_halfcomplex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_HALFCOMPLEX_FLOAT_H__ +-#define __GSL_FFT_HALFCOMPLEX_FLOAT_H__ +- +-#include +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_fft_halfcomplex_float_radix2_backward (float data[], const size_t stride, const size_t n); +-int gsl_fft_halfcomplex_float_radix2_inverse (float data[], const size_t stride, const size_t n); +-int gsl_fft_halfcomplex_float_radix2_transform (float data[], const size_t stride, const size_t n); +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex_float *twiddle[64]; +- gsl_complex_float *trig; +- } +-gsl_fft_halfcomplex_wavetable_float; +- +- +-gsl_fft_halfcomplex_wavetable_float * gsl_fft_halfcomplex_wavetable_float_alloc (size_t n); +- +-void +-gsl_fft_halfcomplex_wavetable_float_free (gsl_fft_halfcomplex_wavetable_float * wavetable); +- +-int gsl_fft_halfcomplex_float_backward (float data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable_float * wavetable, +- gsl_fft_real_workspace_float * work); +- +-int gsl_fft_halfcomplex_float_inverse (float data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable_float * wavetable, +- gsl_fft_real_workspace_float * work); +- +-int gsl_fft_halfcomplex_float_transform (float data[], const size_t stride, const size_t n, +- const gsl_fft_halfcomplex_wavetable_float * wavetable, +- gsl_fft_real_workspace_float * work); +- +-int +-gsl_fft_halfcomplex_float_unpack (const float halfcomplex_coefficient[], +- float complex_coefficient[], +- const size_t stride, const size_t n); +- +-int +-gsl_fft_halfcomplex_float_radix2_unpack (const float halfcomplex_coefficient[], +- float complex_coefficient[], +- const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_HALFCOMPLEX_FLOAT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_uint.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_UINT_H__ +-#define __GSL_SORT_UINT_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_uint (unsigned int * data, const size_t stride, const size_t n); +-void gsl_sort_uint_index (size_t * p, const unsigned int * data, const size_t stride, const size_t n); +- +-int gsl_sort_uint_smallest (unsigned int * dest, const size_t k, const unsigned int * src, const size_t stride, const size_t n); +-int gsl_sort_uint_smallest_index (size_t * p, const size_t k, const unsigned int * src, const size_t stride, const size_t n); +- +-int gsl_sort_uint_largest (unsigned int * dest, const size_t k, const unsigned int * src, const size_t stride, const size_t n); +-int gsl_sort_uint_largest_index (size_t * p, const size_t k, const unsigned int * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_dilog.h (revision 14079) +@@ -1,130 +0,0 @@ +-/* specfunc/gsl_sf_dilog.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_DILOG_H__ +-#define __GSL_SF_DILOG_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Real part of DiLogarithm(x), for real argument. +- * In Lewin's notation, this is Li_2(x). +- * +- * Li_2(x) = - Re[ Integrate[ Log[1-s] / s, {s, 0, x}] ] +- * +- * The function in the complex plane has a branch point +- * at z = 1; we place the cut in the conventional way, +- * on [1, +infty). This means that the value for real x > 1 +- * is a matter of definition; however, this choice does not +- * affect the real part and so is not relevant to the +- * interpretation of this implemented function. +- */ +-int gsl_sf_dilog_e(const double x, gsl_sf_result * result); +-double gsl_sf_dilog(const double x); +- +- +-/* DiLogarithm(z), for complex argument z = x + i y. +- * Computes the principal branch. +- * +- * Recall that the branch cut is on the real axis with x > 1. +- * The imaginary part of the computed value on the cut is given +- * by -Pi*log(x), which is the limiting value taken approaching +- * from y < 0. This is a conventional choice, though there is no +- * true standardized choice. +- * +- * Note that there is no canonical way to lift the defining +- * contour to the full Riemann surface because of the appearance +- * of a "hidden branch point" at z = 0 on non-principal sheets. +- * Experts will know the simple algebraic prescription for +- * obtaining the sheet they want; non-experts will not want +- * to know anything about it. This is why GSL chooses to compute +- * only on the principal branch. +- */ +-int +-gsl_sf_complex_dilog_xy_e( +- const double x, +- const double y, +- gsl_sf_result * result_re, +- gsl_sf_result * result_im +- ); +- +- +- +-/* DiLogarithm(z), for complex argument z = r Exp[i theta]. +- * Computes the principal branch, thereby assuming an +- * implicit reduction of theta to the range (-2 pi, 2 pi). +- * +- * If theta is identically zero, the imaginary part is computed +- * as if approaching from y > 0. For other values of theta no +- * special consideration is given, since it is assumed that +- * no other machine representations of multiples of pi will +- * produce y = 0 precisely. This assumption depends on some +- * subtle properties of the machine arithmetic, such as +- * correct rounding and monotonicity of the underlying +- * implementation of sin() and cos(). +- * +- * This function is ok, but the interface is confusing since +- * it makes it appear that the branch structure is resolved. +- * Furthermore the handling of values close to the branch +- * cut is subtle. Perhap this interface should be deprecated. +- */ +-int +-gsl_sf_complex_dilog_e( +- const double r, +- const double theta, +- gsl_sf_result * result_re, +- gsl_sf_result * result_im +- ); +- +- +- +-/* Spence integral; spence(s) := Li_2(1-s) +- * +- * This function has a branch point at 0; we place the +- * cut on (-infty,0). Because of our choice for the value +- * of Li_2(z) on the cut, spence(s) is continuous as +- * s approaches the cut from above. In other words, +- * we define spence(x) = spence(x + i 0+). +- */ +-int +-gsl_sf_complex_spence_xy_e( +- const double x, +- const double y, +- gsl_sf_result * real_sp, +- gsl_sf_result * imag_sp +- ); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_DILOG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_char.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_char.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_CHAR_H__ +-#define __GSL_STATISTICS_CHAR_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_char_mean (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_variance (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_sd (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_variance_with_fixed_mean (const char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_char_sd_with_fixed_mean (const char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_char_tss (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_tss_m (const char data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_char_absdev (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_skew (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_kurtosis (const char data[], const size_t stride, const size_t n); +-double gsl_stats_char_lag1_autocorrelation (const char data[], const size_t stride, const size_t n); +- +-double gsl_stats_char_covariance (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n); +-double gsl_stats_char_correlation (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_char_variance_m (const char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_char_sd_m (const char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_char_absdev_m (const char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_char_skew_m_sd (const char data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_char_kurtosis_m_sd (const char data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_char_lag1_autocorrelation_m (const char data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_char_covariance_m (const char data1[], const size_t stride1,const char data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_char_pvariance (const char data1[], const size_t stride1, const size_t n1, const char data2[], const size_t stride2, const size_t n2); +-double gsl_stats_char_ttest (const char data1[], const size_t stride1, const size_t n1, const char data2[], const size_t stride2, const size_t n2); +- +-char gsl_stats_char_max (const char data[], const size_t stride, const size_t n); +-char gsl_stats_char_min (const char data[], const size_t stride, const size_t n); +-void gsl_stats_char_minmax (char * min, char * max, const char data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_char_max_index (const char data[], const size_t stride, const size_t n); +-size_t gsl_stats_char_min_index (const char data[], const size_t stride, const size_t n); +-void gsl_stats_char_minmax_index (size_t * min_index, size_t * max_index, const char data[], const size_t stride, const size_t n); +- +-double gsl_stats_char_median_from_sorted_data (const char sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_char_quantile_from_sorted_data (const char sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_CHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_ieee_utils.h (revision 14079) +@@ -1,99 +0,0 @@ +-/* ieee-utils/gsl_ieee_utils.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_IEEE_UTILS_H__ +-#define __GSL_IEEE_UTILS_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-enum { +- GSL_IEEE_TYPE_NAN = 1, +- GSL_IEEE_TYPE_INF = 2, +- GSL_IEEE_TYPE_NORMAL = 3, +- GSL_IEEE_TYPE_DENORMAL = 4, +- GSL_IEEE_TYPE_ZERO = 5 +-} ; +- +-typedef struct { +- int sign ; +- char mantissa[24] ; /* Actual bits are 0..22, element 23 is \0 */ +- int exponent ; +- int type ; +-} gsl_ieee_float_rep ; +- +-typedef struct { +- int sign ; +- char mantissa[53] ; /* Actual bits are 0..51, element 52 is \0 */ +- int exponent ; +- int type ; +-} gsl_ieee_double_rep ; +- +- +-void gsl_ieee_printf_float (const float * x) ; +-void gsl_ieee_printf_double (const double * x) ; +- +-void gsl_ieee_fprintf_float (FILE * stream, const float * x) ; +-void gsl_ieee_fprintf_double (FILE * stream, const double * x) ; +- +-void gsl_ieee_float_to_rep (const float * x, gsl_ieee_float_rep * r) ; +-void gsl_ieee_double_to_rep (const double * x, gsl_ieee_double_rep * r) ; +- +-enum { +- GSL_IEEE_SINGLE_PRECISION = 1, +- GSL_IEEE_DOUBLE_PRECISION = 2, +- GSL_IEEE_EXTENDED_PRECISION = 3 +-} ; +- +-enum { +- GSL_IEEE_ROUND_TO_NEAREST = 1, +- GSL_IEEE_ROUND_DOWN = 2, +- GSL_IEEE_ROUND_UP = 3, +- GSL_IEEE_ROUND_TO_ZERO = 4 +-} ; +- +-enum { +- GSL_IEEE_MASK_INVALID = 1, +- GSL_IEEE_MASK_DENORMALIZED = 2, +- GSL_IEEE_MASK_DIVISION_BY_ZERO = 4, +- GSL_IEEE_MASK_OVERFLOW = 8, +- GSL_IEEE_MASK_UNDERFLOW = 16, +- GSL_IEEE_MASK_ALL = 31, +- GSL_IEEE_TRAP_INEXACT = 32 +-} ; +- +-void gsl_ieee_env_setup (void) ; +-int gsl_ieee_read_mode_string (const char * description, int * precision, +- int * rounding, int * exception_mask) ; +-int gsl_ieee_set_mode (int precision, int rounding, int exception_mask) ; +- +-__END_DECLS +- +-#endif /* __GSL_IEEE_UTILS_H__ */ +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_float.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_FLOAT_H__ +-#define __GSL_VECTOR_FLOAT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- float *data; +- gsl_block_float *block; +- int owner; +-} +-gsl_vector_float; +- +-typedef struct +-{ +- gsl_vector_float vector; +-} _gsl_vector_float_view; +- +-typedef _gsl_vector_float_view gsl_vector_float_view; +- +-typedef struct +-{ +- gsl_vector_float vector; +-} _gsl_vector_float_const_view; +- +-typedef const _gsl_vector_float_const_view gsl_vector_float_const_view; +- +- +-/* Allocation */ +- +-gsl_vector_float *gsl_vector_float_alloc (const size_t n); +-gsl_vector_float *gsl_vector_float_calloc (const size_t n); +- +-gsl_vector_float *gsl_vector_float_alloc_from_block (gsl_block_float * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_float *gsl_vector_float_alloc_from_vector (gsl_vector_float * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_float_free (gsl_vector_float * v); +- +-/* Views */ +- +-_gsl_vector_float_view +-gsl_vector_float_view_array (float *v, size_t n); +- +-_gsl_vector_float_view +-gsl_vector_float_view_array_with_stride (float *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_float_const_view +-gsl_vector_float_const_view_array (const float *v, size_t n); +- +-_gsl_vector_float_const_view +-gsl_vector_float_const_view_array_with_stride (const float *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_float_view +-gsl_vector_float_subvector (gsl_vector_float *v, +- size_t i, +- size_t n); +- +-_gsl_vector_float_view +-gsl_vector_float_subvector_with_stride (gsl_vector_float *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_float_const_view +-gsl_vector_float_const_subvector (const gsl_vector_float *v, +- size_t i, +- size_t n); +- +-_gsl_vector_float_const_view +-gsl_vector_float_const_subvector_with_stride (const gsl_vector_float *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_float_set_zero (gsl_vector_float * v); +-void gsl_vector_float_set_all (gsl_vector_float * v, float x); +-int gsl_vector_float_set_basis (gsl_vector_float * v, size_t i); +- +-int gsl_vector_float_fread (FILE * stream, gsl_vector_float * v); +-int gsl_vector_float_fwrite (FILE * stream, const gsl_vector_float * v); +-int gsl_vector_float_fscanf (FILE * stream, gsl_vector_float * v); +-int gsl_vector_float_fprintf (FILE * stream, const gsl_vector_float * v, +- const char *format); +- +-int gsl_vector_float_memcpy (gsl_vector_float * dest, const gsl_vector_float * src); +- +-int gsl_vector_float_reverse (gsl_vector_float * v); +- +-int gsl_vector_float_swap (gsl_vector_float * v, gsl_vector_float * w); +-int gsl_vector_float_swap_elements (gsl_vector_float * v, const size_t i, const size_t j); +- +-float gsl_vector_float_max (const gsl_vector_float * v); +-float gsl_vector_float_min (const gsl_vector_float * v); +-void gsl_vector_float_minmax (const gsl_vector_float * v, float * min_out, float * max_out); +- +-size_t gsl_vector_float_max_index (const gsl_vector_float * v); +-size_t gsl_vector_float_min_index (const gsl_vector_float * v); +-void gsl_vector_float_minmax_index (const gsl_vector_float * v, size_t * imin, size_t * imax); +- +-int gsl_vector_float_add (gsl_vector_float * a, const gsl_vector_float * b); +-int gsl_vector_float_sub (gsl_vector_float * a, const gsl_vector_float * b); +-int gsl_vector_float_mul (gsl_vector_float * a, const gsl_vector_float * b); +-int gsl_vector_float_div (gsl_vector_float * a, const gsl_vector_float * b); +-int gsl_vector_float_scale (gsl_vector_float * a, const double x); +-int gsl_vector_float_add_constant (gsl_vector_float * a, const double x); +- +-int gsl_vector_float_equal (const gsl_vector_float * u, +- const gsl_vector_float * v); +- +-int gsl_vector_float_isnull (const gsl_vector_float * v); +-int gsl_vector_float_ispos (const gsl_vector_float * v); +-int gsl_vector_float_isneg (const gsl_vector_float * v); +-int gsl_vector_float_isnonneg (const gsl_vector_float * v); +- +-INLINE_DECL float gsl_vector_float_get (const gsl_vector_float * v, const size_t i); +-INLINE_DECL void gsl_vector_float_set (gsl_vector_float * v, const size_t i, float x); +-INLINE_DECL float * gsl_vector_float_ptr (gsl_vector_float * v, const size_t i); +-INLINE_DECL const float * gsl_vector_float_const_ptr (const gsl_vector_float * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-float +-gsl_vector_float_get (const gsl_vector_float * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_float_set (gsl_vector_float * v, const size_t i, float x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-float * +-gsl_vector_float_ptr (gsl_vector_float * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (float *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const float * +-gsl_vector_float_const_ptr (const gsl_vector_float * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const float *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_FLOAT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_uint.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_UINT_H__ +-#define __GSL_BLOCK_UINT_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_uint_struct +-{ +- size_t size; +- unsigned int *data; +-}; +- +-typedef struct gsl_block_uint_struct gsl_block_uint; +- +-gsl_block_uint *gsl_block_uint_alloc (const size_t n); +-gsl_block_uint *gsl_block_uint_calloc (const size_t n); +-void gsl_block_uint_free (gsl_block_uint * b); +- +-int gsl_block_uint_fread (FILE * stream, gsl_block_uint * b); +-int gsl_block_uint_fwrite (FILE * stream, const gsl_block_uint * b); +-int gsl_block_uint_fscanf (FILE * stream, gsl_block_uint * b); +-int gsl_block_uint_fprintf (FILE * stream, const gsl_block_uint * b, const char *format); +- +-int gsl_block_uint_raw_fread (FILE * stream, unsigned int * b, const size_t n, const size_t stride); +-int gsl_block_uint_raw_fwrite (FILE * stream, const unsigned int * b, const size_t n, const size_t stride); +-int gsl_block_uint_raw_fscanf (FILE * stream, unsigned int * b, const size_t n, const size_t stride); +-int gsl_block_uint_raw_fprintf (FILE * stream, const unsigned int * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_uint_size (const gsl_block_uint * b); +-unsigned int * gsl_block_uint_data (const gsl_block_uint * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics.h (revision 14079) +@@ -1,20 +0,0 @@ +-#ifndef __GSL_STATISTICS_H__ +-#define __GSL_STATISTICS_H__ +- +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-#endif /* __GSL_STATISTICS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_complex_float.h (revision 14079) +@@ -1,139 +0,0 @@ +-/* fft/gsl_fft_complex_float.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_COMPLEX_FLOAT_H__ +-#define __GSL_FFT_COMPLEX_FLOAT_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Power of 2 routines */ +- +- +-int gsl_fft_complex_float_radix2_forward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_backward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_inverse (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_transform (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n, +- const gsl_fft_direction sign); +- +-int gsl_fft_complex_float_radix2_dif_forward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_dif_backward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_dif_inverse (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n); +- +-int gsl_fft_complex_float_radix2_dif_transform (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n, +- const gsl_fft_direction sign); +- +-/* Mixed Radix general-N routines */ +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex_float *twiddle[64]; +- gsl_complex_float *trig; +- } +-gsl_fft_complex_wavetable_float; +- +-typedef struct +-{ +- size_t n; +- float *scratch; +-} +-gsl_fft_complex_workspace_float; +- +- +-gsl_fft_complex_wavetable_float *gsl_fft_complex_wavetable_float_alloc (size_t n); +- +-void gsl_fft_complex_wavetable_float_free (gsl_fft_complex_wavetable_float * wavetable); +- +-gsl_fft_complex_workspace_float *gsl_fft_complex_workspace_float_alloc (size_t n); +- +-void gsl_fft_complex_workspace_float_free (gsl_fft_complex_workspace_float * workspace); +- +- +-int gsl_fft_complex_float_memcpy (gsl_fft_complex_wavetable_float * dest, +- gsl_fft_complex_wavetable_float * src); +- +- +-int gsl_fft_complex_float_forward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable_float * wavetable, +- gsl_fft_complex_workspace_float * work); +- +-int gsl_fft_complex_float_backward (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable_float * wavetable, +- gsl_fft_complex_workspace_float * work); +- +-int gsl_fft_complex_float_inverse (gsl_complex_packed_array_float data, +- const size_t stride, +- const size_t n, +- const gsl_fft_complex_wavetable_float * wavetable, +- gsl_fft_complex_workspace_float * work); +- +-int gsl_fft_complex_float_transform (gsl_complex_packed_array_float data, +- const size_t stride, const size_t n, +- const gsl_fft_complex_wavetable_float * wavetable, +- gsl_fft_complex_workspace_float * work, +- const gsl_fft_direction sign); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_COMPLEX_FLOAT_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sf_fermi_dirac.h (revision 14079) +@@ -1,126 +0,0 @@ +-/* specfunc/gsl_sf_fermi_dirac.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +-#ifndef __GSL_SF_FERMI_DIRAC_H__ +-#define __GSL_SF_FERMI_DIRAC_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Complete Fermi-Dirac Integrals: +- * +- * F_j(x) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,0,Infinity}] +- * +- * +- * Incomplete Fermi-Dirac Integrals: +- * +- * F_j(x,b) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,b,Infinity}] +- */ +- +- +-/* Complete integral F_{-1}(x) = e^x / (1 + e^x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_fermi_dirac_m1_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_m1(const double x); +- +- +-/* Complete integral F_0(x) = ln(1 + e^x) +- * +- * exceptions: GSL_EUNDRFLW +- */ +-int gsl_sf_fermi_dirac_0_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_0(const double x); +- +- +-/* Complete integral F_1(x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_1_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_1(const double x); +- +- +-/* Complete integral F_2(x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_2_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_2(const double x); +- +- +-/* Complete integral F_j(x) +- * for integer j +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_int_e(const int j, const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_int(const int j, const double x); +- +- +-/* Complete integral F_{-1/2}(x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_mhalf_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_mhalf(const double x); +- +- +-/* Complete integral F_{1/2}(x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_half_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_half(const double x); +- +- +-/* Complete integral F_{3/2}(x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW +- */ +-int gsl_sf_fermi_dirac_3half_e(const double x, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_3half(const double x); +- +- +-/* Incomplete integral F_0(x,b) = ln(1 + e^(b-x)) - (b-x) +- * +- * exceptions: GSL_EUNDRFLW, GSL_EDOM +- */ +-int gsl_sf_fermi_dirac_inc_0_e(const double x, const double b, gsl_sf_result * result); +-double gsl_sf_fermi_dirac_inc_0(const double x, const double b); +- +- +-__END_DECLS +- +-#endif /* __GSL_SF_FERMI_DIRAC_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_double.h (revision 14079) +@@ -1,230 +0,0 @@ +-/* vector/gsl_vector_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_DOUBLE_H__ +-#define __GSL_VECTOR_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- double *data; +- gsl_block *block; +- int owner; +-} +-gsl_vector; +- +-typedef struct +-{ +- gsl_vector vector; +-} _gsl_vector_view; +- +-typedef _gsl_vector_view gsl_vector_view; +- +-typedef struct +-{ +- gsl_vector vector; +-} _gsl_vector_const_view; +- +-typedef const _gsl_vector_const_view gsl_vector_const_view; +- +- +-/* Allocation */ +- +-gsl_vector *gsl_vector_alloc (const size_t n); +-gsl_vector *gsl_vector_calloc (const size_t n); +- +-gsl_vector *gsl_vector_alloc_from_block (gsl_block * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector *gsl_vector_alloc_from_vector (gsl_vector * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_free (gsl_vector * v); +- +-/* Views */ +- +-_gsl_vector_view +-gsl_vector_view_array (double *v, size_t n); +- +-_gsl_vector_view +-gsl_vector_view_array_with_stride (double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_const_view +-gsl_vector_const_view_array (const double *v, size_t n); +- +-_gsl_vector_const_view +-gsl_vector_const_view_array_with_stride (const double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_view +-gsl_vector_subvector (gsl_vector *v, +- size_t i, +- size_t n); +- +-_gsl_vector_view +-gsl_vector_subvector_with_stride (gsl_vector *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_const_view +-gsl_vector_const_subvector (const gsl_vector *v, +- size_t i, +- size_t n); +- +-_gsl_vector_const_view +-gsl_vector_const_subvector_with_stride (const gsl_vector *v, +- size_t i, +- size_t stride, +- size_t n); +- +-/* Operations */ +- +-void gsl_vector_set_zero (gsl_vector * v); +-void gsl_vector_set_all (gsl_vector * v, double x); +-int gsl_vector_set_basis (gsl_vector * v, size_t i); +- +-int gsl_vector_fread (FILE * stream, gsl_vector * v); +-int gsl_vector_fwrite (FILE * stream, const gsl_vector * v); +-int gsl_vector_fscanf (FILE * stream, gsl_vector * v); +-int gsl_vector_fprintf (FILE * stream, const gsl_vector * v, +- const char *format); +- +-int gsl_vector_memcpy (gsl_vector * dest, const gsl_vector * src); +- +-int gsl_vector_reverse (gsl_vector * v); +- +-int gsl_vector_swap (gsl_vector * v, gsl_vector * w); +-int gsl_vector_swap_elements (gsl_vector * v, const size_t i, const size_t j); +- +-double gsl_vector_max (const gsl_vector * v); +-double gsl_vector_min (const gsl_vector * v); +-void gsl_vector_minmax (const gsl_vector * v, double * min_out, double * max_out); +- +-size_t gsl_vector_max_index (const gsl_vector * v); +-size_t gsl_vector_min_index (const gsl_vector * v); +-void gsl_vector_minmax_index (const gsl_vector * v, size_t * imin, size_t * imax); +- +-int gsl_vector_add (gsl_vector * a, const gsl_vector * b); +-int gsl_vector_sub (gsl_vector * a, const gsl_vector * b); +-int gsl_vector_mul (gsl_vector * a, const gsl_vector * b); +-int gsl_vector_div (gsl_vector * a, const gsl_vector * b); +-int gsl_vector_scale (gsl_vector * a, const double x); +-int gsl_vector_add_constant (gsl_vector * a, const double x); +- +-int gsl_vector_equal (const gsl_vector * u, +- const gsl_vector * v); +- +-int gsl_vector_isnull (const gsl_vector * v); +-int gsl_vector_ispos (const gsl_vector * v); +-int gsl_vector_isneg (const gsl_vector * v); +-int gsl_vector_isnonneg (const gsl_vector * v); +- +-INLINE_DECL double gsl_vector_get (const gsl_vector * v, const size_t i); +-INLINE_DECL void gsl_vector_set (gsl_vector * v, const size_t i, double x); +-INLINE_DECL double * gsl_vector_ptr (gsl_vector * v, const size_t i); +-INLINE_DECL const double * gsl_vector_const_ptr (const gsl_vector * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-double +-gsl_vector_get (const gsl_vector * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, 0); +- } +-#endif +- return v->data[i * v->stride]; +-} +- +-INLINE_FUN +-void +-gsl_vector_set (gsl_vector * v, const size_t i, double x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- v->data[i * v->stride] = x; +-} +- +-INLINE_FUN +-double * +-gsl_vector_ptr (gsl_vector * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (double *) (v->data + i * v->stride); +-} +- +-INLINE_FUN +-const double * +-gsl_vector_const_ptr (const gsl_vector * v, const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return (const double *) (v->data + i * v->stride); +-} +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_DOUBLE_H__ */ +- +- +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long_double.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_long_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_LONG_DOUBLE_H__ +-#define __GSL_SORT_LONG_DOUBLE_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_long_double (long double * data, const size_t stride, const size_t n); +-void gsl_sort_long_double_index (size_t * p, const long double * data, const size_t stride, const size_t n); +- +-int gsl_sort_long_double_smallest (long double * dest, const size_t k, const long double * src, const size_t stride, const size_t n); +-int gsl_sort_long_double_smallest_index (size_t * p, const size_t k, const long double * src, const size_t stride, const size_t n); +- +-int gsl_sort_long_double_largest (long double * dest, const size_t k, const long double * src, const size_t stride, const size_t n); +-int gsl_sort_long_double_largest_index (size_t * p, const size_t k, const long double * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_LONG_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_mksa.h (revision 14079) +@@ -1,126 +0,0 @@ +-/* const/gsl_const_mksa.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- * 2006, 2007, 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST_MKSA__ +-#define __GSL_CONST_MKSA__ +- +-#define GSL_CONST_MKSA_SPEED_OF_LIGHT (2.99792458e8) /* m / s */ +-#define GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT (6.673e-11) /* m^3 / kg s^2 */ +-#define GSL_CONST_MKSA_PLANCKS_CONSTANT_H (6.62606896e-34) /* kg m^2 / s */ +-#define GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR (1.05457162825e-34) /* kg m^2 / s */ +-#define GSL_CONST_MKSA_ASTRONOMICAL_UNIT (1.49597870691e11) /* m */ +-#define GSL_CONST_MKSA_LIGHT_YEAR (9.46053620707e15) /* m */ +-#define GSL_CONST_MKSA_PARSEC (3.08567758135e16) /* m */ +-#define GSL_CONST_MKSA_GRAV_ACCEL (9.80665e0) /* m / s^2 */ +-#define GSL_CONST_MKSA_ELECTRON_VOLT (1.602176487e-19) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_MASS_ELECTRON (9.10938188e-31) /* kg */ +-#define GSL_CONST_MKSA_MASS_MUON (1.88353109e-28) /* kg */ +-#define GSL_CONST_MKSA_MASS_PROTON (1.67262158e-27) /* kg */ +-#define GSL_CONST_MKSA_MASS_NEUTRON (1.67492716e-27) /* kg */ +-#define GSL_CONST_MKSA_RYDBERG (2.17987196968e-18) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_BOLTZMANN (1.3806504e-23) /* kg m^2 / K s^2 */ +-#define GSL_CONST_MKSA_MOLAR_GAS (8.314472e0) /* kg m^2 / K mol s^2 */ +-#define GSL_CONST_MKSA_STANDARD_GAS_VOLUME (2.2710981e-2) /* m^3 / mol */ +-#define GSL_CONST_MKSA_MINUTE (6e1) /* s */ +-#define GSL_CONST_MKSA_HOUR (3.6e3) /* s */ +-#define GSL_CONST_MKSA_DAY (8.64e4) /* s */ +-#define GSL_CONST_MKSA_WEEK (6.048e5) /* s */ +-#define GSL_CONST_MKSA_INCH (2.54e-2) /* m */ +-#define GSL_CONST_MKSA_FOOT (3.048e-1) /* m */ +-#define GSL_CONST_MKSA_YARD (9.144e-1) /* m */ +-#define GSL_CONST_MKSA_MILE (1.609344e3) /* m */ +-#define GSL_CONST_MKSA_NAUTICAL_MILE (1.852e3) /* m */ +-#define GSL_CONST_MKSA_FATHOM (1.8288e0) /* m */ +-#define GSL_CONST_MKSA_MIL (2.54e-5) /* m */ +-#define GSL_CONST_MKSA_POINT (3.52777777778e-4) /* m */ +-#define GSL_CONST_MKSA_TEXPOINT (3.51459803515e-4) /* m */ +-#define GSL_CONST_MKSA_MICRON (1e-6) /* m */ +-#define GSL_CONST_MKSA_ANGSTROM (1e-10) /* m */ +-#define GSL_CONST_MKSA_HECTARE (1e4) /* m^2 */ +-#define GSL_CONST_MKSA_ACRE (4.04685642241e3) /* m^2 */ +-#define GSL_CONST_MKSA_BARN (1e-28) /* m^2 */ +-#define GSL_CONST_MKSA_LITER (1e-3) /* m^3 */ +-#define GSL_CONST_MKSA_US_GALLON (3.78541178402e-3) /* m^3 */ +-#define GSL_CONST_MKSA_QUART (9.46352946004e-4) /* m^3 */ +-#define GSL_CONST_MKSA_PINT (4.73176473002e-4) /* m^3 */ +-#define GSL_CONST_MKSA_CUP (2.36588236501e-4) /* m^3 */ +-#define GSL_CONST_MKSA_FLUID_OUNCE (2.95735295626e-5) /* m^3 */ +-#define GSL_CONST_MKSA_TABLESPOON (1.47867647813e-5) /* m^3 */ +-#define GSL_CONST_MKSA_TEASPOON (4.92892159375e-6) /* m^3 */ +-#define GSL_CONST_MKSA_CANADIAN_GALLON (4.54609e-3) /* m^3 */ +-#define GSL_CONST_MKSA_UK_GALLON (4.546092e-3) /* m^3 */ +-#define GSL_CONST_MKSA_MILES_PER_HOUR (4.4704e-1) /* m / s */ +-#define GSL_CONST_MKSA_KILOMETERS_PER_HOUR (2.77777777778e-1) /* m / s */ +-#define GSL_CONST_MKSA_KNOT (5.14444444444e-1) /* m / s */ +-#define GSL_CONST_MKSA_POUND_MASS (4.5359237e-1) /* kg */ +-#define GSL_CONST_MKSA_OUNCE_MASS (2.8349523125e-2) /* kg */ +-#define GSL_CONST_MKSA_TON (9.0718474e2) /* kg */ +-#define GSL_CONST_MKSA_METRIC_TON (1e3) /* kg */ +-#define GSL_CONST_MKSA_UK_TON (1.0160469088e3) /* kg */ +-#define GSL_CONST_MKSA_TROY_OUNCE (3.1103475e-2) /* kg */ +-#define GSL_CONST_MKSA_CARAT (2e-4) /* kg */ +-#define GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS (1.660538782e-27) /* kg */ +-#define GSL_CONST_MKSA_GRAM_FORCE (9.80665e-3) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_POUND_FORCE (4.44822161526e0) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_KILOPOUND_FORCE (4.44822161526e3) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_POUNDAL (1.38255e-1) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_CALORIE (4.1868e0) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_BTU (1.05505585262e3) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_THERM (1.05506e8) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_HORSEPOWER (7.457e2) /* kg m^2 / s^3 */ +-#define GSL_CONST_MKSA_BAR (1e5) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_STD_ATMOSPHERE (1.01325e5) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_TORR (1.33322368421e2) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_METER_OF_MERCURY (1.33322368421e5) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_INCH_OF_MERCURY (3.38638815789e3) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_INCH_OF_WATER (2.490889e2) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_PSI (6.89475729317e3) /* kg / m s^2 */ +-#define GSL_CONST_MKSA_POISE (1e-1) /* kg m^-1 s^-1 */ +-#define GSL_CONST_MKSA_STOKES (1e-4) /* m^2 / s */ +-#define GSL_CONST_MKSA_STILB (1e4) /* cd / m^2 */ +-#define GSL_CONST_MKSA_LUMEN (1e0) /* cd sr */ +-#define GSL_CONST_MKSA_LUX (1e0) /* cd sr / m^2 */ +-#define GSL_CONST_MKSA_PHOT (1e4) /* cd sr / m^2 */ +-#define GSL_CONST_MKSA_FOOTCANDLE (1.076e1) /* cd sr / m^2 */ +-#define GSL_CONST_MKSA_LAMBERT (1e4) /* cd sr / m^2 */ +-#define GSL_CONST_MKSA_FOOTLAMBERT (1.07639104e1) /* cd sr / m^2 */ +-#define GSL_CONST_MKSA_CURIE (3.7e10) /* 1 / s */ +-#define GSL_CONST_MKSA_ROENTGEN (2.58e-4) /* A s / kg */ +-#define GSL_CONST_MKSA_RAD (1e-2) /* m^2 / s^2 */ +-#define GSL_CONST_MKSA_SOLAR_MASS (1.98892e30) /* kg */ +-#define GSL_CONST_MKSA_BOHR_RADIUS (5.291772083e-11) /* m */ +-#define GSL_CONST_MKSA_NEWTON (1e0) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_DYNE (1e-5) /* kg m / s^2 */ +-#define GSL_CONST_MKSA_JOULE (1e0) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_ERG (1e-7) /* kg m^2 / s^2 */ +-#define GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-8) /* kg / K^4 s^3 */ +-#define GSL_CONST_MKSA_THOMSON_CROSS_SECTION (6.65245893699e-29) /* m^2 */ +-#define GSL_CONST_MKSA_BOHR_MAGNETON (9.27400899e-24) /* A m^2 */ +-#define GSL_CONST_MKSA_NUCLEAR_MAGNETON (5.05078317e-27) /* A m^2 */ +-#define GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT (9.28476362e-24) /* A m^2 */ +-#define GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT (1.410606633e-26) /* A m^2 */ +-#define GSL_CONST_MKSA_FARADAY (9.64853429775e4) /* A s / mol */ +-#define GSL_CONST_MKSA_ELECTRON_CHARGE (1.602176487e-19) /* A s */ +-#define GSL_CONST_MKSA_VACUUM_PERMITTIVITY (8.854187817e-12) /* A^2 s^4 / kg m^3 */ +-#define GSL_CONST_MKSA_VACUUM_PERMEABILITY (1.25663706144e-6) /* kg m / A^2 s^2 */ +-#define GSL_CONST_MKSA_DEBYE (3.33564095198e-30) /* A s^2 / m^2 */ +-#define GSL_CONST_MKSA_GAUSS (1e-4) /* kg / A s^2 */ +- +-#endif /* __GSL_CONST_MKSA__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_uint.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_uint.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_UINT_H__ +-#define __GSL_MATRIX_UINT_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- unsigned int * data; +- gsl_block_uint * block; +- int owner; +-} gsl_matrix_uint; +- +-typedef struct +-{ +- gsl_matrix_uint matrix; +-} _gsl_matrix_uint_view; +- +-typedef _gsl_matrix_uint_view gsl_matrix_uint_view; +- +-typedef struct +-{ +- gsl_matrix_uint matrix; +-} _gsl_matrix_uint_const_view; +- +-typedef const _gsl_matrix_uint_const_view gsl_matrix_uint_const_view; +- +-/* Allocation */ +- +-gsl_matrix_uint * +-gsl_matrix_uint_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_uint * +-gsl_matrix_uint_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_uint * +-gsl_matrix_uint_alloc_from_block (gsl_block_uint * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_uint * +-gsl_matrix_uint_alloc_from_matrix (gsl_matrix_uint * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_uint * +-gsl_vector_uint_alloc_row_from_matrix (gsl_matrix_uint * m, +- const size_t i); +- +-gsl_vector_uint * +-gsl_vector_uint_alloc_col_from_matrix (gsl_matrix_uint * m, +- const size_t j); +- +-void gsl_matrix_uint_free (gsl_matrix_uint * m); +- +-/* Views */ +- +-_gsl_matrix_uint_view +-gsl_matrix_uint_submatrix (gsl_matrix_uint * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_row (gsl_matrix_uint * m, const size_t i); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_column (gsl_matrix_uint * m, const size_t j); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_diagonal (gsl_matrix_uint * m); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_subdiagonal (gsl_matrix_uint * m, const size_t k); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_superdiagonal (gsl_matrix_uint * m, const size_t k); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_subrow (gsl_matrix_uint * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_uint_view +-gsl_matrix_uint_subcolumn (gsl_matrix_uint * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_uint_view +-gsl_matrix_uint_view_array (unsigned int * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uint_view +-gsl_matrix_uint_view_array_with_tda (unsigned int * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_uint_view +-gsl_matrix_uint_view_vector (gsl_vector_uint * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uint_view +-gsl_matrix_uint_view_vector_with_tda (gsl_vector_uint * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_uint_const_view +-gsl_matrix_uint_const_submatrix (const gsl_matrix_uint * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_row (const gsl_matrix_uint * m, +- const size_t i); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_column (const gsl_matrix_uint * m, +- const size_t j); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_diagonal (const gsl_matrix_uint * m); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_subdiagonal (const gsl_matrix_uint * m, +- const size_t k); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_superdiagonal (const gsl_matrix_uint * m, +- const size_t k); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_subrow (const gsl_matrix_uint * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_uint_const_view +-gsl_matrix_uint_const_subcolumn (const gsl_matrix_uint * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_uint_const_view +-gsl_matrix_uint_const_view_array (const unsigned int * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uint_const_view +-gsl_matrix_uint_const_view_array_with_tda (const unsigned int * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_uint_const_view +-gsl_matrix_uint_const_view_vector (const gsl_vector_uint * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_uint_const_view +-gsl_matrix_uint_const_view_vector_with_tda (const gsl_vector_uint * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_uint_set_zero (gsl_matrix_uint * m); +-void gsl_matrix_uint_set_identity (gsl_matrix_uint * m); +-void gsl_matrix_uint_set_all (gsl_matrix_uint * m, unsigned int x); +- +-int gsl_matrix_uint_fread (FILE * stream, gsl_matrix_uint * m) ; +-int gsl_matrix_uint_fwrite (FILE * stream, const gsl_matrix_uint * m) ; +-int gsl_matrix_uint_fscanf (FILE * stream, gsl_matrix_uint * m); +-int gsl_matrix_uint_fprintf (FILE * stream, const gsl_matrix_uint * m, const char * format); +- +-int gsl_matrix_uint_memcpy(gsl_matrix_uint * dest, const gsl_matrix_uint * src); +-int gsl_matrix_uint_swap(gsl_matrix_uint * m1, gsl_matrix_uint * m2); +- +-int gsl_matrix_uint_swap_rows(gsl_matrix_uint * m, const size_t i, const size_t j); +-int gsl_matrix_uint_swap_columns(gsl_matrix_uint * m, const size_t i, const size_t j); +-int gsl_matrix_uint_swap_rowcol(gsl_matrix_uint * m, const size_t i, const size_t j); +-int gsl_matrix_uint_transpose (gsl_matrix_uint * m); +-int gsl_matrix_uint_transpose_memcpy (gsl_matrix_uint * dest, const gsl_matrix_uint * src); +- +-unsigned int gsl_matrix_uint_max (const gsl_matrix_uint * m); +-unsigned int gsl_matrix_uint_min (const gsl_matrix_uint * m); +-void gsl_matrix_uint_minmax (const gsl_matrix_uint * m, unsigned int * min_out, unsigned int * max_out); +- +-void gsl_matrix_uint_max_index (const gsl_matrix_uint * m, size_t * imax, size_t *jmax); +-void gsl_matrix_uint_min_index (const gsl_matrix_uint * m, size_t * imin, size_t *jmin); +-void gsl_matrix_uint_minmax_index (const gsl_matrix_uint * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_uint_equal (const gsl_matrix_uint * a, const gsl_matrix_uint * b); +- +-int gsl_matrix_uint_isnull (const gsl_matrix_uint * m); +-int gsl_matrix_uint_ispos (const gsl_matrix_uint * m); +-int gsl_matrix_uint_isneg (const gsl_matrix_uint * m); +-int gsl_matrix_uint_isnonneg (const gsl_matrix_uint * m); +- +-int gsl_matrix_uint_add (gsl_matrix_uint * a, const gsl_matrix_uint * b); +-int gsl_matrix_uint_sub (gsl_matrix_uint * a, const gsl_matrix_uint * b); +-int gsl_matrix_uint_mul_elements (gsl_matrix_uint * a, const gsl_matrix_uint * b); +-int gsl_matrix_uint_div_elements (gsl_matrix_uint * a, const gsl_matrix_uint * b); +-int gsl_matrix_uint_scale (gsl_matrix_uint * a, const double x); +-int gsl_matrix_uint_add_constant (gsl_matrix_uint * a, const double x); +-int gsl_matrix_uint_add_diagonal (gsl_matrix_uint * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_uint_get_row(gsl_vector_uint * v, const gsl_matrix_uint * m, const size_t i); +-int gsl_matrix_uint_get_col(gsl_vector_uint * v, const gsl_matrix_uint * m, const size_t j); +-int gsl_matrix_uint_set_row(gsl_matrix_uint * m, const size_t i, const gsl_vector_uint * v); +-int gsl_matrix_uint_set_col(gsl_matrix_uint * m, const size_t j, const gsl_vector_uint * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL unsigned int gsl_matrix_uint_get(const gsl_matrix_uint * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_uint_set(gsl_matrix_uint * m, const size_t i, const size_t j, const unsigned int x); +-INLINE_DECL unsigned int * gsl_matrix_uint_ptr(gsl_matrix_uint * m, const size_t i, const size_t j); +-INLINE_DECL const unsigned int * gsl_matrix_uint_const_ptr(const gsl_matrix_uint * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-unsigned int +-gsl_matrix_uint_get(const gsl_matrix_uint * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_uint_set(gsl_matrix_uint * m, const size_t i, const size_t j, const unsigned int x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-unsigned int * +-gsl_matrix_uint_ptr(gsl_matrix_uint * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (unsigned int *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const unsigned int * +-gsl_matrix_uint_const_ptr(const gsl_matrix_uint * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const unsigned int *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_UINT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_randist.h (revision 14079) +@@ -1,185 +0,0 @@ +-/* randist/gsl_randist.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 James Theiler, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_RANDIST_H__ +-#define __GSL_RANDIST_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-unsigned int gsl_ran_bernoulli (const gsl_rng * r, double p); +-double gsl_ran_bernoulli_pdf (const unsigned int k, double p); +- +-double gsl_ran_beta (const gsl_rng * r, const double a, const double b); +-double gsl_ran_beta_pdf (const double x, const double a, const double b); +- +-unsigned int gsl_ran_binomial (const gsl_rng * r, double p, unsigned int n); +-unsigned int gsl_ran_binomial_knuth (const gsl_rng * r, double p, unsigned int n); +-unsigned int gsl_ran_binomial_tpe (const gsl_rng * r, double p, unsigned int n); +-double gsl_ran_binomial_pdf (const unsigned int k, const double p, const unsigned int n); +- +-double gsl_ran_exponential (const gsl_rng * r, const double mu); +-double gsl_ran_exponential_pdf (const double x, const double mu); +- +-double gsl_ran_exppow (const gsl_rng * r, const double a, const double b); +-double gsl_ran_exppow_pdf (const double x, const double a, const double b); +- +-double gsl_ran_cauchy (const gsl_rng * r, const double a); +-double gsl_ran_cauchy_pdf (const double x, const double a); +- +-double gsl_ran_chisq (const gsl_rng * r, const double nu); +-double gsl_ran_chisq_pdf (const double x, const double nu); +- +-void gsl_ran_dirichlet (const gsl_rng * r, const size_t K, const double alpha[], double theta[]); +-double gsl_ran_dirichlet_pdf (const size_t K, const double alpha[], const double theta[]); +-double gsl_ran_dirichlet_lnpdf (const size_t K, const double alpha[], const double theta[]); +- +-double gsl_ran_erlang (const gsl_rng * r, const double a, const double n); +-double gsl_ran_erlang_pdf (const double x, const double a, const double n); +- +-double gsl_ran_fdist (const gsl_rng * r, const double nu1, const double nu2); +-double gsl_ran_fdist_pdf (const double x, const double nu1, const double nu2); +- +-double gsl_ran_flat (const gsl_rng * r, const double a, const double b); +-double gsl_ran_flat_pdf (double x, const double a, const double b); +- +-double gsl_ran_gamma (const gsl_rng * r, const double a, const double b); +-double gsl_ran_gamma_int (const gsl_rng * r, const unsigned int a); +-double gsl_ran_gamma_pdf (const double x, const double a, const double b); +-double gsl_ran_gamma_mt (const gsl_rng * r, const double a, const double b); +-double gsl_ran_gamma_knuth (const gsl_rng * r, const double a, const double b); +- +-double gsl_ran_gaussian (const gsl_rng * r, const double sigma); +-double gsl_ran_gaussian_ratio_method (const gsl_rng * r, const double sigma); +-double gsl_ran_gaussian_ziggurat (const gsl_rng * r, const double sigma); +-double gsl_ran_gaussian_pdf (const double x, const double sigma); +- +-double gsl_ran_ugaussian (const gsl_rng * r); +-double gsl_ran_ugaussian_ratio_method (const gsl_rng * r); +-double gsl_ran_ugaussian_pdf (const double x); +- +-double gsl_ran_gaussian_tail (const gsl_rng * r, const double a, const double sigma); +-double gsl_ran_gaussian_tail_pdf (const double x, const double a, const double sigma); +- +-double gsl_ran_ugaussian_tail (const gsl_rng * r, const double a); +-double gsl_ran_ugaussian_tail_pdf (const double x, const double a); +- +-void gsl_ran_bivariate_gaussian (const gsl_rng * r, double sigma_x, double sigma_y, double rho, double *x, double *y); +-double gsl_ran_bivariate_gaussian_pdf (const double x, const double y, const double sigma_x, const double sigma_y, const double rho); +- +-double gsl_ran_landau (const gsl_rng * r); +-double gsl_ran_landau_pdf (const double x); +- +-unsigned int gsl_ran_geometric (const gsl_rng * r, const double p); +-double gsl_ran_geometric_pdf (const unsigned int k, const double p); +- +-unsigned int gsl_ran_hypergeometric (const gsl_rng * r, unsigned int n1, unsigned int n2, unsigned int t); +-double gsl_ran_hypergeometric_pdf (const unsigned int k, const unsigned int n1, const unsigned int n2, unsigned int t); +- +-double gsl_ran_gumbel1 (const gsl_rng * r, const double a, const double b); +-double gsl_ran_gumbel1_pdf (const double x, const double a, const double b); +- +-double gsl_ran_gumbel2 (const gsl_rng * r, const double a, const double b); +-double gsl_ran_gumbel2_pdf (const double x, const double a, const double b); +- +-double gsl_ran_logistic (const gsl_rng * r, const double a); +-double gsl_ran_logistic_pdf (const double x, const double a); +- +-double gsl_ran_lognormal (const gsl_rng * r, const double zeta, const double sigma); +-double gsl_ran_lognormal_pdf (const double x, const double zeta, const double sigma); +- +-unsigned int gsl_ran_logarithmic (const gsl_rng * r, const double p); +-double gsl_ran_logarithmic_pdf (const unsigned int k, const double p); +- +-void gsl_ran_multinomial (const gsl_rng * r, const size_t K, +- const unsigned int N, const double p[], +- unsigned int n[] ); +-double gsl_ran_multinomial_pdf (const size_t K, +- const double p[], const unsigned int n[] ); +-double gsl_ran_multinomial_lnpdf (const size_t K, +- const double p[], const unsigned int n[] ); +- +- +-unsigned int gsl_ran_negative_binomial (const gsl_rng * r, double p, double n); +-double gsl_ran_negative_binomial_pdf (const unsigned int k, const double p, double n); +- +-unsigned int gsl_ran_pascal (const gsl_rng * r, double p, unsigned int n); +-double gsl_ran_pascal_pdf (const unsigned int k, const double p, unsigned int n); +- +-double gsl_ran_pareto (const gsl_rng * r, double a, const double b); +-double gsl_ran_pareto_pdf (const double x, const double a, const double b); +- +-unsigned int gsl_ran_poisson (const gsl_rng * r, double mu); +-void gsl_ran_poisson_array (const gsl_rng * r, size_t n, unsigned int array[], +- double mu); +-double gsl_ran_poisson_pdf (const unsigned int k, const double mu); +- +-double gsl_ran_rayleigh (const gsl_rng * r, const double sigma); +-double gsl_ran_rayleigh_pdf (const double x, const double sigma); +- +-double gsl_ran_rayleigh_tail (const gsl_rng * r, const double a, const double sigma); +-double gsl_ran_rayleigh_tail_pdf (const double x, const double a, const double sigma); +- +-double gsl_ran_tdist (const gsl_rng * r, const double nu); +-double gsl_ran_tdist_pdf (const double x, const double nu); +- +-double gsl_ran_laplace (const gsl_rng * r, const double a); +-double gsl_ran_laplace_pdf (const double x, const double a); +- +-double gsl_ran_levy (const gsl_rng * r, const double c, const double alpha); +-double gsl_ran_levy_skew (const gsl_rng * r, const double c, const double alpha, const double beta); +- +-double gsl_ran_weibull (const gsl_rng * r, const double a, const double b); +-double gsl_ran_weibull_pdf (const double x, const double a, const double b); +- +-void gsl_ran_dir_2d (const gsl_rng * r, double * x, double * y); +-void gsl_ran_dir_2d_trig_method (const gsl_rng * r, double * x, double * y); +-void gsl_ran_dir_3d (const gsl_rng * r, double * x, double * y, double * z); +-void gsl_ran_dir_nd (const gsl_rng * r, size_t n, double * x); +- +-void gsl_ran_shuffle (const gsl_rng * r, void * base, size_t nmembm, size_t size); +-int gsl_ran_choose (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ; +-void gsl_ran_sample (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ; +- +- +-typedef struct { /* struct for Walker algorithm */ +- size_t K; +- size_t *A; +- double *F; +-} gsl_ran_discrete_t; +- +-gsl_ran_discrete_t * gsl_ran_discrete_preproc (size_t K, const double *P); +-void gsl_ran_discrete_free(gsl_ran_discrete_t *g); +-size_t gsl_ran_discrete (const gsl_rng *r, const gsl_ran_discrete_t *g); +-double gsl_ran_discrete_pdf (size_t k, const gsl_ran_discrete_t *g); +- +- +-__END_DECLS +- +-#endif /* __GSL_RANDIST_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sum.h (revision 14079) +@@ -1,162 +0,0 @@ +-/* sum/gsl_sum.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-/* Author: G. Jungman */ +- +- +-#ifndef __GSL_SUM_H__ +-#define __GSL_SUM_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-/* Workspace for Levin U Transform with error estimation, +- * +- * size = number of terms the workspace can handle +- * sum_plain = simple sum of series +- * q_num = backward diagonal of numerator; length = size +- * q_den = backward diagonal of denominator; length = size +- * dq_num = table of numerator derivatives; length = size**2 +- * dq_den = table of denominator derivatives; length = size**2 +- * dsum = derivative of sum wrt term i; length = size +- */ +- +-typedef struct +-{ +- size_t size; +- size_t i; /* position in array */ +- size_t terms_used; /* number of calls */ +- double sum_plain; +- double *q_num; +- double *q_den; +- double *dq_num; +- double *dq_den; +- double *dsum; +-} +-gsl_sum_levin_u_workspace; +- +-gsl_sum_levin_u_workspace *gsl_sum_levin_u_alloc (size_t n); +-void gsl_sum_levin_u_free (gsl_sum_levin_u_workspace * w); +- +-/* Basic Levin-u acceleration method. +- * +- * array = array of series elements +- * n = size of array +- * sum_accel = result of summation acceleration +- * err = estimated error +- * +- * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602] +- */ +- +-int gsl_sum_levin_u_accel (const double *array, +- const size_t n, +- gsl_sum_levin_u_workspace * w, +- double *sum_accel, double *abserr); +- +-/* Basic Levin-u acceleration method with constraints on the terms +- * used, +- * +- * array = array of series elements +- * n = size of array +- * min_terms = minimum number of terms to sum +- * max_terms = maximum number of terms to sum +- * sum_accel = result of summation acceleration +- * err = estimated error +- * +- * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602] +- */ +- +-int gsl_sum_levin_u_minmax (const double *array, +- const size_t n, +- const size_t min_terms, +- const size_t max_terms, +- gsl_sum_levin_u_workspace * w, +- double *sum_accel, double *abserr); +- +-/* Basic Levin-u step w/o reference to the array of terms. +- * We only need to specify the value of the current term +- * to execute the step. See TOMS-745. +- * +- * sum = t0 + ... + t_{n-1} + term; term = t_{n} +- * +- * term = value of the series term to be added +- * n = position of term in series (starting from 0) +- * sum_accel = result of summation acceleration +- * sum_plain = simple sum of series +- */ +- +-int +-gsl_sum_levin_u_step (const double term, +- const size_t n, +- const size_t nmax, +- gsl_sum_levin_u_workspace * w, +- double *sum_accel); +- +-/* The following functions perform the same calculation without +- estimating the errors. They require O(N) storage instead of O(N^2). +- This may be useful for summing many similar series where the size +- of the error has already been estimated reliably and is not +- expected to change. */ +- +-typedef struct +-{ +- size_t size; +- size_t i; /* position in array */ +- size_t terms_used; /* number of calls */ +- double sum_plain; +- double *q_num; +- double *q_den; +- double *dsum; +-} +-gsl_sum_levin_utrunc_workspace; +- +-gsl_sum_levin_utrunc_workspace *gsl_sum_levin_utrunc_alloc (size_t n); +-void gsl_sum_levin_utrunc_free (gsl_sum_levin_utrunc_workspace * w); +- +-int gsl_sum_levin_utrunc_accel (const double *array, +- const size_t n, +- gsl_sum_levin_utrunc_workspace * w, +- double *sum_accel, double *abserr_trunc); +- +-int gsl_sum_levin_utrunc_minmax (const double *array, +- const size_t n, +- const size_t min_terms, +- const size_t max_terms, +- gsl_sum_levin_utrunc_workspace * w, +- double *sum_accel, double *abserr_trunc); +- +-int gsl_sum_levin_utrunc_step (const double term, +- const size_t n, +- gsl_sum_levin_utrunc_workspace * w, +- double *sum_accel); +- +-__END_DECLS +- +-#endif /* __GSL_SUM_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sort_long.h (revision 14079) +@@ -1,50 +0,0 @@ +-/* sort/gsl_sort_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Thomas Walter, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SORT_LONG_H__ +-#define __GSL_SORT_LONG_H__ +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-void gsl_sort_long (long * data, const size_t stride, const size_t n); +-void gsl_sort_long_index (size_t * p, const long * data, const size_t stride, const size_t n); +- +-int gsl_sort_long_smallest (long * dest, const size_t k, const long * src, const size_t stride, const size_t n); +-int gsl_sort_long_smallest_index (size_t * p, const size_t k, const long * src, const size_t stride, const size_t n); +- +-int gsl_sort_long_largest (long * dest, const size_t k, const long * src, const size_t stride, const size_t n); +-int gsl_sort_long_largest_index (size_t * p, const size_t k, const long * src, const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_SORT_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_qrng.h (revision 14079) +@@ -1,111 +0,0 @@ +-/* Author: G. Jungman + modifications from O. Teytaud +- */ +-#ifndef __GSL_QRNG_H__ +-#define __GSL_QRNG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* Once again, more inane C-style OOP... kill me now. */ +- +-/* Structure describing a type of generator. +- */ +-typedef struct +-{ +- const char * name; +- unsigned int max_dimension; +- size_t (*state_size) (unsigned int dimension); +- int (*init_state) (void * state, unsigned int dimension); +- int (*get) (void * state, unsigned int dimension, double x[]); +-} +-gsl_qrng_type; +- +-/* Structure describing a generator instance of a +- * specified type, with generator-specific state info +- * and dimension-specific info. +- */ +-typedef struct +-{ +- const gsl_qrng_type * type; +- unsigned int dimension; +- size_t state_size; +- void * state; +-} +-gsl_qrng; +- +- +-/* Supported generator types. +- */ +-GSL_VAR const gsl_qrng_type * gsl_qrng_niederreiter_2; +-GSL_VAR const gsl_qrng_type * gsl_qrng_sobol; +-GSL_VAR const gsl_qrng_type * gsl_qrng_halton; +-GSL_VAR const gsl_qrng_type * gsl_qrng_reversehalton; +- +- +-/* Allocate and initialize a generator +- * of the specified type, in the given +- * space dimension. +- */ +-gsl_qrng * gsl_qrng_alloc (const gsl_qrng_type * T, unsigned int dimension); +- +- +-/* Copy a generator. */ +-int gsl_qrng_memcpy (gsl_qrng * dest, const gsl_qrng * src); +- +- +-/* Clone a generator. */ +-gsl_qrng * gsl_qrng_clone (const gsl_qrng * q); +- +- +-/* Free a generator. */ +-void gsl_qrng_free (gsl_qrng * q); +- +- +-/* Intialize a generator. */ +-void gsl_qrng_init (gsl_qrng * q); +- +- +-/* Get the standardized name of the generator. */ +-const char * gsl_qrng_name (const gsl_qrng * q); +- +- +-/* ISN'T THIS CONFUSING FOR PEOPLE? +- WHAT IF SOMEBODY TRIES TO COPY WITH THIS ??? +- */ +-size_t gsl_qrng_size (const gsl_qrng * q); +- +- +-void * gsl_qrng_state (const gsl_qrng * q); +- +- +-/* Retrieve next vector in sequence. */ +-INLINE_DECL int gsl_qrng_get (const gsl_qrng * q, double x[]); +- +-#ifdef HAVE_INLINE +-INLINE_FUN int gsl_qrng_get (const gsl_qrng * q, double x[]) +-{ +- return (q->type->get) (q->state, q->dimension, x); +-} +- +-#endif /* HAVE_INLINE */ +- +- +-__END_DECLS +- +- +-#endif /* !__GSL_QRNG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_permute_vector_ulong.h (revision 14079) +@@ -1,45 +0,0 @@ +-/* permutation/gsl_permute_vector_ulong.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_PERMUTE_VECTOR_ULONG_H__ +-#define __GSL_PERMUTE_VECTOR_ULONG_H__ +- +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_permute_vector_ulong (const gsl_permutation * p, gsl_vector_ulong * v); +-int gsl_permute_vector_ulong_inverse (const gsl_permutation * p, gsl_vector_ulong * v); +- +-__END_DECLS +- +-#endif /* __GSL_PERMUTE_VECTOR_ULONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_diff.h (revision 14079) +@@ -1,52 +0,0 @@ +-/* diff/gsl_diff.h +- * +- * Copyright (C) 2000 David Morrison +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_DIFF_H__ +-#define __GSL_DIFF_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-#ifndef GSL_DISABLE_DEPRECATED +-int gsl_diff_central (const gsl_function *f, +- double x, +- double *result, double *abserr); +- +-int gsl_diff_backward (const gsl_function *f, +- double x, +- double *result, double *abserr); +- +-int gsl_diff_forward (const gsl_function *f, +- double x, +- double *result, double *abserr); +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_DIFF_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_block_long.h (revision 14079) +@@ -1,65 +0,0 @@ +-/* block/gsl_block_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_BLOCK_LONG_H__ +-#define __GSL_BLOCK_LONG_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-struct gsl_block_long_struct +-{ +- size_t size; +- long *data; +-}; +- +-typedef struct gsl_block_long_struct gsl_block_long; +- +-gsl_block_long *gsl_block_long_alloc (const size_t n); +-gsl_block_long *gsl_block_long_calloc (const size_t n); +-void gsl_block_long_free (gsl_block_long * b); +- +-int gsl_block_long_fread (FILE * stream, gsl_block_long * b); +-int gsl_block_long_fwrite (FILE * stream, const gsl_block_long * b); +-int gsl_block_long_fscanf (FILE * stream, gsl_block_long * b); +-int gsl_block_long_fprintf (FILE * stream, const gsl_block_long * b, const char *format); +- +-int gsl_block_long_raw_fread (FILE * stream, long * b, const size_t n, const size_t stride); +-int gsl_block_long_raw_fwrite (FILE * stream, const long * b, const size_t n, const size_t stride); +-int gsl_block_long_raw_fscanf (FILE * stream, long * b, const size_t n, const size_t stride); +-int gsl_block_long_raw_fprintf (FILE * stream, const long * b, const size_t n, const size_t stride, const char *format); +- +-size_t gsl_block_long_size (const gsl_block_long * b); +-long * gsl_block_long_data (const gsl_block_long * b); +- +-__END_DECLS +- +-#endif /* __GSL_BLOCK_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_statistics_uchar.h (revision 14079) +@@ -1,79 +0,0 @@ +-/* statistics/gsl_statistics_uchar.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Jim Davies, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_STATISTICS_UCHAR_H__ +-#define __GSL_STATISTICS_UCHAR_H__ +- +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_stats_uchar_mean (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_variance (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_sd (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_variance_with_fixed_mean (const unsigned char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uchar_sd_with_fixed_mean (const unsigned char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uchar_tss (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_tss_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_uchar_absdev (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_skew (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_kurtosis (const unsigned char data[], const size_t stride, const size_t n); +-double gsl_stats_uchar_lag1_autocorrelation (const unsigned char data[], const size_t stride, const size_t n); +- +-double gsl_stats_uchar_covariance (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n); +-double gsl_stats_uchar_correlation (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n); +- +-double gsl_stats_uchar_variance_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uchar_sd_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uchar_absdev_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); +-double gsl_stats_uchar_skew_m_sd (const unsigned char data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_uchar_kurtosis_m_sd (const unsigned char data[], const size_t stride, const size_t n, const double mean, const double sd); +-double gsl_stats_uchar_lag1_autocorrelation_m (const unsigned char data[], const size_t stride, const size_t n, const double mean); +- +-double gsl_stats_uchar_covariance_m (const unsigned char data1[], const size_t stride1,const unsigned char data2[], const size_t stride2, const size_t n, const double mean1, const double mean2); +- +- +-double gsl_stats_uchar_pvariance (const unsigned char data1[], const size_t stride1, const size_t n1, const unsigned char data2[], const size_t stride2, const size_t n2); +-double gsl_stats_uchar_ttest (const unsigned char data1[], const size_t stride1, const size_t n1, const unsigned char data2[], const size_t stride2, const size_t n2); +- +-unsigned char gsl_stats_uchar_max (const unsigned char data[], const size_t stride, const size_t n); +-unsigned char gsl_stats_uchar_min (const unsigned char data[], const size_t stride, const size_t n); +-void gsl_stats_uchar_minmax (unsigned char * min, unsigned char * max, const unsigned char data[], const size_t stride, const size_t n); +- +-size_t gsl_stats_uchar_max_index (const unsigned char data[], const size_t stride, const size_t n); +-size_t gsl_stats_uchar_min_index (const unsigned char data[], const size_t stride, const size_t n); +-void gsl_stats_uchar_minmax_index (size_t * min_index, size_t * max_index, const unsigned char data[], const size_t stride, const size_t n); +- +-double gsl_stats_uchar_median_from_sorted_data (const unsigned char sorted_data[], const size_t stride, const size_t n) ; +-double gsl_stats_uchar_quantile_from_sorted_data (const unsigned char sorted_data[], const size_t stride, const size_t n, const double f) ; +- +-__END_DECLS +- +-#endif /* __GSL_STATISTICS_UCHAR_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_sys.h (revision 14079) +@@ -1,63 +0,0 @@ +-/* sys/gsl_sys.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_SYS_H__ +-#define __GSL_SYS_H__ +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-double gsl_log1p (const double x); +-double gsl_expm1 (const double x); +-double gsl_hypot (const double x, const double y); +-double gsl_hypot3 (const double x, const double y, const double z); +-double gsl_acosh (const double x); +-double gsl_asinh (const double x); +-double gsl_atanh (const double x); +- +-int gsl_isnan (const double x); +-int gsl_isinf (const double x); +-int gsl_finite (const double x); +- +-double gsl_nan (void); +-double gsl_posinf (void); +-double gsl_neginf (void); +-double gsl_fdiv (const double x, const double y); +- +-double gsl_coerce_double (const double x); +-float gsl_coerce_float (const float x); +-long double gsl_coerce_long_double (const long double x); +- +-double gsl_ldexp(const double x, const int e); +-double gsl_frexp(const double x, int * e); +- +-int gsl_fcmp (const double x1, const double x2, const double epsilon); +- +-__END_DECLS +- +-#endif /* __GSL_SYS_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_pow_int.h (revision 14079) +@@ -1,61 +0,0 @@ +-/* gsl_pow_int.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_POW_INT_H__ +-#define __GSL_POW_INT_H__ +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-INLINE_DECL double gsl_pow_2(const double x); +-INLINE_DECL double gsl_pow_3(const double x); +-INLINE_DECL double gsl_pow_4(const double x); +-INLINE_DECL double gsl_pow_5(const double x); +-INLINE_DECL double gsl_pow_6(const double x); +-INLINE_DECL double gsl_pow_7(const double x); +-INLINE_DECL double gsl_pow_8(const double x); +-INLINE_DECL double gsl_pow_9(const double x); +- +-#ifdef HAVE_INLINE +-INLINE_FUN double gsl_pow_2(const double x) { return x*x; } +-INLINE_FUN double gsl_pow_3(const double x) { return x*x*x; } +-INLINE_FUN double gsl_pow_4(const double x) { double x2 = x*x; return x2*x2; } +-INLINE_FUN double gsl_pow_5(const double x) { double x2 = x*x; return x2*x2*x; } +-INLINE_FUN double gsl_pow_6(const double x) { double x2 = x*x; return x2*x2*x2; } +-INLINE_FUN double gsl_pow_7(const double x) { double x3 = x*x*x; return x3*x3*x; } +-INLINE_FUN double gsl_pow_8(const double x) { double x2 = x*x; double x4 = x2*x2; return x4*x4; } +-INLINE_FUN double gsl_pow_9(const double x) { double x3 = x*x*x; return x3*x3*x3; } +-#endif +- +-double gsl_pow_int(double x, int n); +-double gsl_pow_uint(double x, unsigned int n); +- +-__END_DECLS +- +-#endif /* __GSL_POW_INT_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_chebyshev.h (revision 14079) +@@ -1,133 +0,0 @@ +-/* cheb/gsl_chebyshev.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CHEBYSHEV_H__ +-#define __GSL_CHEBYSHEV_H__ +- +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +- +-/* data for a Chebyshev series over a given interval */ +- +-struct gsl_cheb_series_struct { +- +- double * c; /* coefficients */ +- size_t order; /* order of expansion */ +- double a; /* lower interval point */ +- double b; /* upper interval point */ +- +- /* The following exists (mostly) for the benefit +- * of the implementation. It is an effective single +- * precision order, for use in single precision +- * evaluation. Users can use it if they like, but +- * only they know how to calculate it, since it is +- * specific to the approximated function. By default, +- * order_sp = order. +- * It is used explicitly only by the gsl_cheb_eval_mode +- * functions, which are not meant for casual use. +- */ +- size_t order_sp; +- +- /* Additional elements not used by specfunc */ +- +- double * f; /* function evaluated at chebyschev points */ +-}; +-typedef struct gsl_cheb_series_struct gsl_cheb_series; +- +- +-/* Calculate a Chebyshev series of specified order over +- * a specified interval, for a given function. +- * Return 0 on failure. +- */ +-gsl_cheb_series * gsl_cheb_alloc(const size_t order); +- +-/* Free a Chebyshev series previously calculated with gsl_cheb_alloc(). +- */ +-void gsl_cheb_free(gsl_cheb_series * cs); +- +-/* Calculate a Chebyshev series using the storage provided. +- * Uses the interval (a,b) and the order with which it +- * was initially created. +- * +- */ +-int gsl_cheb_init(gsl_cheb_series * cs, const gsl_function * func, +- const double a, const double b); +- +-/* Return the order, size of coefficient array and coefficient array ptr */ +-size_t gsl_cheb_order (const gsl_cheb_series * cs); +-size_t gsl_cheb_size (const gsl_cheb_series * cs); +-double *gsl_cheb_coeffs (const gsl_cheb_series * cs); +- +-/* Evaluate a Chebyshev series at a given point. +- * No errors can occur for a struct obtained from gsl_cheb_new(). +- */ +-double gsl_cheb_eval(const gsl_cheb_series * cs, const double x); +-int gsl_cheb_eval_err(const gsl_cheb_series * cs, const double x, +- double * result, double * abserr); +- +- +-/* Evaluate a Chebyshev series at a given point, to (at most) the given order. +- * No errors can occur for a struct obtained from gsl_cheb_new(). +- */ +-double gsl_cheb_eval_n(const gsl_cheb_series * cs, const size_t order, +- const double x); +-int gsl_cheb_eval_n_err(const gsl_cheb_series * cs, const size_t order, +- const double x, double * result, double * abserr); +- +- +-/* Evaluate a Chebyshev series at a given point, using the default +- * order for double precision mode(s) and the single precision +- * order for other modes. +- * No errors can occur for a struct obtained from gsl_cheb_new(). +- */ +-double gsl_cheb_eval_mode(const gsl_cheb_series * cs, const double x, gsl_mode_t mode); +-int gsl_cheb_eval_mode_e(const gsl_cheb_series * cs, const double x, gsl_mode_t mode, double * result, double * abserr); +- +- +- +-/* Compute the derivative of a Chebyshev series. +- */ +-int gsl_cheb_calc_deriv(gsl_cheb_series * deriv, const gsl_cheb_series * cs); +- +-/* Compute the integral of a Chebyshev series. The +- * integral is fixed by the condition that it equals zero at +- * the left end-point, ie it is precisely +- * Integrate[cs(t; a,b), {t, a, x}] +- */ +-int gsl_cheb_calc_integ(gsl_cheb_series * integ, const gsl_cheb_series * cs); +- +- +- +- +-__END_DECLS +- +-#endif /* __GSL_CHEBYSHEV_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_const_cgs.h (revision 14079) +@@ -1,116 +0,0 @@ +-/* const/gsl_const_cgs.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +- * 2006, 2007, 2008, 2009 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_CONST_CGS__ +-#define __GSL_CONST_CGS__ +- +-#define GSL_CONST_CGS_SPEED_OF_LIGHT (2.99792458e10) /* cm / s */ +-#define GSL_CONST_CGS_GRAVITATIONAL_CONSTANT (6.673e-8) /* cm^3 / g s^2 */ +-#define GSL_CONST_CGS_PLANCKS_CONSTANT_H (6.62606896e-27) /* g cm^2 / s */ +-#define GSL_CONST_CGS_PLANCKS_CONSTANT_HBAR (1.05457162825e-27) /* g cm^2 / s */ +-#define GSL_CONST_CGS_ASTRONOMICAL_UNIT (1.49597870691e13) /* cm */ +-#define GSL_CONST_CGS_LIGHT_YEAR (9.46053620707e17) /* cm */ +-#define GSL_CONST_CGS_PARSEC (3.08567758135e18) /* cm */ +-#define GSL_CONST_CGS_GRAV_ACCEL (9.80665e2) /* cm / s^2 */ +-#define GSL_CONST_CGS_ELECTRON_VOLT (1.602176487e-12) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_MASS_ELECTRON (9.10938188e-28) /* g */ +-#define GSL_CONST_CGS_MASS_MUON (1.88353109e-25) /* g */ +-#define GSL_CONST_CGS_MASS_PROTON (1.67262158e-24) /* g */ +-#define GSL_CONST_CGS_MASS_NEUTRON (1.67492716e-24) /* g */ +-#define GSL_CONST_CGS_RYDBERG (2.17987196968e-11) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_BOLTZMANN (1.3806504e-16) /* g cm^2 / K s^2 */ +-#define GSL_CONST_CGS_MOLAR_GAS (8.314472e7) /* g cm^2 / K mol s^2 */ +-#define GSL_CONST_CGS_STANDARD_GAS_VOLUME (2.2710981e4) /* cm^3 / mol */ +-#define GSL_CONST_CGS_MINUTE (6e1) /* s */ +-#define GSL_CONST_CGS_HOUR (3.6e3) /* s */ +-#define GSL_CONST_CGS_DAY (8.64e4) /* s */ +-#define GSL_CONST_CGS_WEEK (6.048e5) /* s */ +-#define GSL_CONST_CGS_INCH (2.54e0) /* cm */ +-#define GSL_CONST_CGS_FOOT (3.048e1) /* cm */ +-#define GSL_CONST_CGS_YARD (9.144e1) /* cm */ +-#define GSL_CONST_CGS_MILE (1.609344e5) /* cm */ +-#define GSL_CONST_CGS_NAUTICAL_MILE (1.852e5) /* cm */ +-#define GSL_CONST_CGS_FATHOM (1.8288e2) /* cm */ +-#define GSL_CONST_CGS_MIL (2.54e-3) /* cm */ +-#define GSL_CONST_CGS_POINT (3.52777777778e-2) /* cm */ +-#define GSL_CONST_CGS_TEXPOINT (3.51459803515e-2) /* cm */ +-#define GSL_CONST_CGS_MICRON (1e-4) /* cm */ +-#define GSL_CONST_CGS_ANGSTROM (1e-8) /* cm */ +-#define GSL_CONST_CGS_HECTARE (1e8) /* cm^2 */ +-#define GSL_CONST_CGS_ACRE (4.04685642241e7) /* cm^2 */ +-#define GSL_CONST_CGS_BARN (1e-24) /* cm^2 */ +-#define GSL_CONST_CGS_LITER (1e3) /* cm^3 */ +-#define GSL_CONST_CGS_US_GALLON (3.78541178402e3) /* cm^3 */ +-#define GSL_CONST_CGS_QUART (9.46352946004e2) /* cm^3 */ +-#define GSL_CONST_CGS_PINT (4.73176473002e2) /* cm^3 */ +-#define GSL_CONST_CGS_CUP (2.36588236501e2) /* cm^3 */ +-#define GSL_CONST_CGS_FLUID_OUNCE (2.95735295626e1) /* cm^3 */ +-#define GSL_CONST_CGS_TABLESPOON (1.47867647813e1) /* cm^3 */ +-#define GSL_CONST_CGS_TEASPOON (4.92892159375e0) /* cm^3 */ +-#define GSL_CONST_CGS_CANADIAN_GALLON (4.54609e3) /* cm^3 */ +-#define GSL_CONST_CGS_UK_GALLON (4.546092e3) /* cm^3 */ +-#define GSL_CONST_CGS_MILES_PER_HOUR (4.4704e1) /* cm / s */ +-#define GSL_CONST_CGS_KILOMETERS_PER_HOUR (2.77777777778e1) /* cm / s */ +-#define GSL_CONST_CGS_KNOT (5.14444444444e1) /* cm / s */ +-#define GSL_CONST_CGS_POUND_MASS (4.5359237e2) /* g */ +-#define GSL_CONST_CGS_OUNCE_MASS (2.8349523125e1) /* g */ +-#define GSL_CONST_CGS_TON (9.0718474e5) /* g */ +-#define GSL_CONST_CGS_METRIC_TON (1e6) /* g */ +-#define GSL_CONST_CGS_UK_TON (1.0160469088e6) /* g */ +-#define GSL_CONST_CGS_TROY_OUNCE (3.1103475e1) /* g */ +-#define GSL_CONST_CGS_CARAT (2e-1) /* g */ +-#define GSL_CONST_CGS_UNIFIED_ATOMIC_MASS (1.660538782e-24) /* g */ +-#define GSL_CONST_CGS_GRAM_FORCE (9.80665e2) /* cm g / s^2 */ +-#define GSL_CONST_CGS_POUND_FORCE (4.44822161526e5) /* cm g / s^2 */ +-#define GSL_CONST_CGS_KILOPOUND_FORCE (4.44822161526e8) /* cm g / s^2 */ +-#define GSL_CONST_CGS_POUNDAL (1.38255e4) /* cm g / s^2 */ +-#define GSL_CONST_CGS_CALORIE (4.1868e7) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_BTU (1.05505585262e10) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_THERM (1.05506e15) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_HORSEPOWER (7.457e9) /* g cm^2 / s^3 */ +-#define GSL_CONST_CGS_BAR (1e6) /* g / cm s^2 */ +-#define GSL_CONST_CGS_STD_ATMOSPHERE (1.01325e6) /* g / cm s^2 */ +-#define GSL_CONST_CGS_TORR (1.33322368421e3) /* g / cm s^2 */ +-#define GSL_CONST_CGS_METER_OF_MERCURY (1.33322368421e6) /* g / cm s^2 */ +-#define GSL_CONST_CGS_INCH_OF_MERCURY (3.38638815789e4) /* g / cm s^2 */ +-#define GSL_CONST_CGS_INCH_OF_WATER (2.490889e3) /* g / cm s^2 */ +-#define GSL_CONST_CGS_PSI (6.89475729317e4) /* g / cm s^2 */ +-#define GSL_CONST_CGS_POISE (1e0) /* g / cm s */ +-#define GSL_CONST_CGS_STOKES (1e0) /* cm^2 / s */ +-#define GSL_CONST_CGS_STILB (1e0) /* cd / cm^2 */ +-#define GSL_CONST_CGS_LUMEN (1e0) /* cd sr */ +-#define GSL_CONST_CGS_LUX (1e-4) /* cd sr / cm^2 */ +-#define GSL_CONST_CGS_PHOT (1e0) /* cd sr / cm^2 */ +-#define GSL_CONST_CGS_FOOTCANDLE (1.076e-3) /* cd sr / cm^2 */ +-#define GSL_CONST_CGS_LAMBERT (1e0) /* cd sr / cm^2 */ +-#define GSL_CONST_CGS_FOOTLAMBERT (1.07639104e-3) /* cd sr / cm^2 */ +-#define GSL_CONST_CGS_CURIE (3.7e10) /* 1 / s */ +-#define GSL_CONST_CGS_ROENTGEN (2.58e-7) /* A s / g */ +-#define GSL_CONST_CGS_RAD (1e2) /* cm^2 / s^2 */ +-#define GSL_CONST_CGS_SOLAR_MASS (1.98892e33) /* g */ +-#define GSL_CONST_CGS_BOHR_RADIUS (5.291772083e-9) /* cm */ +-#define GSL_CONST_CGS_NEWTON (1e5) /* cm g / s^2 */ +-#define GSL_CONST_CGS_DYNE (1e0) /* cm g / s^2 */ +-#define GSL_CONST_CGS_JOULE (1e7) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_ERG (1e0) /* g cm^2 / s^2 */ +-#define GSL_CONST_CGS_STEFAN_BOLTZMANN_CONSTANT (5.67040047374e-5) /* g / K^4 s^3 */ +-#define GSL_CONST_CGS_THOMSON_CROSS_SECTION (6.65245893699e-25) /* cm^2 */ +- +-#endif /* __GSL_CONST_CGS__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_fft_real.h (revision 14079) +@@ -1,80 +0,0 @@ +-/* fft/gsl_fft_real.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_FFT_REAL_H__ +-#define __GSL_FFT_REAL_H__ +- +-#include +- +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-int gsl_fft_real_radix2_transform (double data[], const size_t stride, const size_t n) ; +- +-typedef struct +- { +- size_t n; +- size_t nf; +- size_t factor[64]; +- gsl_complex *twiddle[64]; +- gsl_complex *trig; +- } +-gsl_fft_real_wavetable; +- +-typedef struct +- { +- size_t n; +- double *scratch; +- } +-gsl_fft_real_workspace; +- +-gsl_fft_real_wavetable * gsl_fft_real_wavetable_alloc (size_t n); +- +-void gsl_fft_real_wavetable_free (gsl_fft_real_wavetable * wavetable); +- +-gsl_fft_real_workspace * gsl_fft_real_workspace_alloc (size_t n); +- +-void gsl_fft_real_workspace_free (gsl_fft_real_workspace * workspace); +- +- +-int gsl_fft_real_transform (double data[], const size_t stride, const size_t n, +- const gsl_fft_real_wavetable * wavetable, +- gsl_fft_real_workspace * work); +- +- +-int gsl_fft_real_unpack (const double real_coefficient[], +- double complex_coefficient[], +- const size_t stride, const size_t n); +- +-__END_DECLS +- +-#endif /* __GSL_FFT_REAL_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_vector_complex_double.h (revision 14079) +@@ -1,251 +0,0 @@ +-/* vector/gsl_vector_complex_double.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_VECTOR_COMPLEX_DOUBLE_H__ +-#define __GSL_VECTOR_COMPLEX_DOUBLE_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size; +- size_t stride; +- double *data; +- gsl_block_complex *block; +- int owner; +-} gsl_vector_complex; +- +-typedef struct +-{ +- gsl_vector_complex vector; +-} _gsl_vector_complex_view; +- +-typedef _gsl_vector_complex_view gsl_vector_complex_view; +- +-typedef struct +-{ +- gsl_vector_complex vector; +-} _gsl_vector_complex_const_view; +- +-typedef const _gsl_vector_complex_const_view gsl_vector_complex_const_view; +- +-/* Allocation */ +- +-gsl_vector_complex *gsl_vector_complex_alloc (const size_t n); +-gsl_vector_complex *gsl_vector_complex_calloc (const size_t n); +- +-gsl_vector_complex * +-gsl_vector_complex_alloc_from_block (gsl_block_complex * b, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-gsl_vector_complex * +-gsl_vector_complex_alloc_from_vector (gsl_vector_complex * v, +- const size_t offset, +- const size_t n, +- const size_t stride); +- +-void gsl_vector_complex_free (gsl_vector_complex * v); +- +-/* Views */ +- +-_gsl_vector_complex_view +-gsl_vector_complex_view_array (double *base, +- size_t n); +- +-_gsl_vector_complex_view +-gsl_vector_complex_view_array_with_stride (double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_const_view +-gsl_vector_complex_const_view_array (const double *base, +- size_t n); +- +-_gsl_vector_complex_const_view +-gsl_vector_complex_const_view_array_with_stride (const double *base, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_view +-gsl_vector_complex_subvector (gsl_vector_complex *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_view +-gsl_vector_complex_subvector_with_stride (gsl_vector_complex *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_complex_const_view +-gsl_vector_complex_const_subvector (const gsl_vector_complex *base, +- size_t i, +- size_t n); +- +- +-_gsl_vector_complex_const_view +-gsl_vector_complex_const_subvector_with_stride (const gsl_vector_complex *v, +- size_t i, +- size_t stride, +- size_t n); +- +-_gsl_vector_view +-gsl_vector_complex_real (gsl_vector_complex *v); +- +-_gsl_vector_view +-gsl_vector_complex_imag (gsl_vector_complex *v); +- +-_gsl_vector_const_view +-gsl_vector_complex_const_real (const gsl_vector_complex *v); +- +-_gsl_vector_const_view +-gsl_vector_complex_const_imag (const gsl_vector_complex *v); +- +- +-/* Operations */ +- +-void gsl_vector_complex_set_zero (gsl_vector_complex * v); +-void gsl_vector_complex_set_all (gsl_vector_complex * v, +- gsl_complex z); +-int gsl_vector_complex_set_basis (gsl_vector_complex * v, size_t i); +- +-int gsl_vector_complex_fread (FILE * stream, +- gsl_vector_complex * v); +-int gsl_vector_complex_fwrite (FILE * stream, +- const gsl_vector_complex * v); +-int gsl_vector_complex_fscanf (FILE * stream, +- gsl_vector_complex * v); +-int gsl_vector_complex_fprintf (FILE * stream, +- const gsl_vector_complex * v, +- const char *format); +- +-int gsl_vector_complex_memcpy (gsl_vector_complex * dest, const gsl_vector_complex * src); +- +-int gsl_vector_complex_reverse (gsl_vector_complex * v); +- +-int gsl_vector_complex_swap (gsl_vector_complex * v, gsl_vector_complex * w); +-int gsl_vector_complex_swap_elements (gsl_vector_complex * v, const size_t i, const size_t j); +- +-int gsl_vector_complex_equal (const gsl_vector_complex * u, +- const gsl_vector_complex * v); +- +-int gsl_vector_complex_isnull (const gsl_vector_complex * v); +-int gsl_vector_complex_ispos (const gsl_vector_complex * v); +-int gsl_vector_complex_isneg (const gsl_vector_complex * v); +-int gsl_vector_complex_isnonneg (const gsl_vector_complex * v); +- +-int gsl_vector_complex_add (gsl_vector_complex * a, const gsl_vector_complex * b); +-int gsl_vector_complex_sub (gsl_vector_complex * a, const gsl_vector_complex * b); +-int gsl_vector_complex_mul (gsl_vector_complex * a, const gsl_vector_complex * b); +-int gsl_vector_complex_div (gsl_vector_complex * a, const gsl_vector_complex * b); +-int gsl_vector_complex_scale (gsl_vector_complex * a, const gsl_complex x); +-int gsl_vector_complex_add_constant (gsl_vector_complex * a, const gsl_complex x); +- +-INLINE_DECL gsl_complex gsl_vector_complex_get (const gsl_vector_complex * v, const size_t i); +-INLINE_DECL void gsl_vector_complex_set (gsl_vector_complex * v, const size_t i, gsl_complex z); +-INLINE_DECL gsl_complex *gsl_vector_complex_ptr (gsl_vector_complex * v, const size_t i); +-INLINE_DECL const gsl_complex *gsl_vector_complex_const_ptr (const gsl_vector_complex * v, const size_t i); +- +-#ifdef HAVE_INLINE +- +-INLINE_FUN +-gsl_complex +-gsl_vector_complex_get (const gsl_vector_complex * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- gsl_complex zero = {{0, 0}}; +- GSL_ERROR_VAL ("index out of range", GSL_EINVAL, zero); +- } +-#endif +- return *GSL_COMPLEX_AT (v, i); +-} +- +-INLINE_FUN +-void +-gsl_vector_complex_set (gsl_vector_complex * v, +- const size_t i, gsl_complex z) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_VOID ("index out of range", GSL_EINVAL); +- } +-#endif +- *GSL_COMPLEX_AT (v, i) = z; +-} +- +-INLINE_FUN +-gsl_complex * +-gsl_vector_complex_ptr (gsl_vector_complex * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_AT (v, i); +-} +- +-INLINE_FUN +-const gsl_complex * +-gsl_vector_complex_const_ptr (const gsl_vector_complex * v, +- const size_t i) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(i >= v->size)) +- { +- GSL_ERROR_NULL ("index out of range", GSL_EINVAL); +- } +-#endif +- return GSL_COMPLEX_AT (v, i); +-} +- +- +-#endif /* HAVE_INLINE */ +- +-__END_DECLS +- +-#endif /* __GSL_VECTOR_COMPLEX_DOUBLE_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/gsl/gsl_matrix_long.h (revision 14079) +@@ -1,350 +0,0 @@ +-/* matrix/gsl_matrix_long.h +- * +- * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 3 of the License, or (at +- * your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, but +- * WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +- */ +- +-#ifndef __GSL_MATRIX_LONG_H__ +-#define __GSL_MATRIX_LONG_H__ +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#undef __BEGIN_DECLS +-#undef __END_DECLS +-#ifdef __cplusplus +-# define __BEGIN_DECLS extern "C" { +-# define __END_DECLS } +-#else +-# define __BEGIN_DECLS /* empty */ +-# define __END_DECLS /* empty */ +-#endif +- +-__BEGIN_DECLS +- +-typedef struct +-{ +- size_t size1; +- size_t size2; +- size_t tda; +- long * data; +- gsl_block_long * block; +- int owner; +-} gsl_matrix_long; +- +-typedef struct +-{ +- gsl_matrix_long matrix; +-} _gsl_matrix_long_view; +- +-typedef _gsl_matrix_long_view gsl_matrix_long_view; +- +-typedef struct +-{ +- gsl_matrix_long matrix; +-} _gsl_matrix_long_const_view; +- +-typedef const _gsl_matrix_long_const_view gsl_matrix_long_const_view; +- +-/* Allocation */ +- +-gsl_matrix_long * +-gsl_matrix_long_alloc (const size_t n1, const size_t n2); +- +-gsl_matrix_long * +-gsl_matrix_long_calloc (const size_t n1, const size_t n2); +- +-gsl_matrix_long * +-gsl_matrix_long_alloc_from_block (gsl_block_long * b, +- const size_t offset, +- const size_t n1, +- const size_t n2, +- const size_t d2); +- +-gsl_matrix_long * +-gsl_matrix_long_alloc_from_matrix (gsl_matrix_long * m, +- const size_t k1, +- const size_t k2, +- const size_t n1, +- const size_t n2); +- +-gsl_vector_long * +-gsl_vector_long_alloc_row_from_matrix (gsl_matrix_long * m, +- const size_t i); +- +-gsl_vector_long * +-gsl_vector_long_alloc_col_from_matrix (gsl_matrix_long * m, +- const size_t j); +- +-void gsl_matrix_long_free (gsl_matrix_long * m); +- +-/* Views */ +- +-_gsl_matrix_long_view +-gsl_matrix_long_submatrix (gsl_matrix_long * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_long_view +-gsl_matrix_long_row (gsl_matrix_long * m, const size_t i); +- +-_gsl_vector_long_view +-gsl_matrix_long_column (gsl_matrix_long * m, const size_t j); +- +-_gsl_vector_long_view +-gsl_matrix_long_diagonal (gsl_matrix_long * m); +- +-_gsl_vector_long_view +-gsl_matrix_long_subdiagonal (gsl_matrix_long * m, const size_t k); +- +-_gsl_vector_long_view +-gsl_matrix_long_superdiagonal (gsl_matrix_long * m, const size_t k); +- +-_gsl_vector_long_view +-gsl_matrix_long_subrow (gsl_matrix_long * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_long_view +-gsl_matrix_long_subcolumn (gsl_matrix_long * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_long_view +-gsl_matrix_long_view_array (long * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_view +-gsl_matrix_long_view_array_with_tda (long * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_long_view +-gsl_matrix_long_view_vector (gsl_vector_long * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_view +-gsl_matrix_long_view_vector_with_tda (gsl_vector_long * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +- +-_gsl_matrix_long_const_view +-gsl_matrix_long_const_submatrix (const gsl_matrix_long * m, +- const size_t i, const size_t j, +- const size_t n1, const size_t n2); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_row (const gsl_matrix_long * m, +- const size_t i); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_column (const gsl_matrix_long * m, +- const size_t j); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_diagonal (const gsl_matrix_long * m); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_subdiagonal (const gsl_matrix_long * m, +- const size_t k); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_superdiagonal (const gsl_matrix_long * m, +- const size_t k); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_subrow (const gsl_matrix_long * m, const size_t i, +- const size_t offset, const size_t n); +- +-_gsl_vector_long_const_view +-gsl_matrix_long_const_subcolumn (const gsl_matrix_long * m, const size_t j, +- const size_t offset, const size_t n); +- +-_gsl_matrix_long_const_view +-gsl_matrix_long_const_view_array (const long * base, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_const_view +-gsl_matrix_long_const_view_array_with_tda (const long * base, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-_gsl_matrix_long_const_view +-gsl_matrix_long_const_view_vector (const gsl_vector_long * v, +- const size_t n1, +- const size_t n2); +- +-_gsl_matrix_long_const_view +-gsl_matrix_long_const_view_vector_with_tda (const gsl_vector_long * v, +- const size_t n1, +- const size_t n2, +- const size_t tda); +- +-/* Operations */ +- +-void gsl_matrix_long_set_zero (gsl_matrix_long * m); +-void gsl_matrix_long_set_identity (gsl_matrix_long * m); +-void gsl_matrix_long_set_all (gsl_matrix_long * m, long x); +- +-int gsl_matrix_long_fread (FILE * stream, gsl_matrix_long * m) ; +-int gsl_matrix_long_fwrite (FILE * stream, const gsl_matrix_long * m) ; +-int gsl_matrix_long_fscanf (FILE * stream, gsl_matrix_long * m); +-int gsl_matrix_long_fprintf (FILE * stream, const gsl_matrix_long * m, const char * format); +- +-int gsl_matrix_long_memcpy(gsl_matrix_long * dest, const gsl_matrix_long * src); +-int gsl_matrix_long_swap(gsl_matrix_long * m1, gsl_matrix_long * m2); +- +-int gsl_matrix_long_swap_rows(gsl_matrix_long * m, const size_t i, const size_t j); +-int gsl_matrix_long_swap_columns(gsl_matrix_long * m, const size_t i, const size_t j); +-int gsl_matrix_long_swap_rowcol(gsl_matrix_long * m, const size_t i, const size_t j); +-int gsl_matrix_long_transpose (gsl_matrix_long * m); +-int gsl_matrix_long_transpose_memcpy (gsl_matrix_long * dest, const gsl_matrix_long * src); +- +-long gsl_matrix_long_max (const gsl_matrix_long * m); +-long gsl_matrix_long_min (const gsl_matrix_long * m); +-void gsl_matrix_long_minmax (const gsl_matrix_long * m, long * min_out, long * max_out); +- +-void gsl_matrix_long_max_index (const gsl_matrix_long * m, size_t * imax, size_t *jmax); +-void gsl_matrix_long_min_index (const gsl_matrix_long * m, size_t * imin, size_t *jmin); +-void gsl_matrix_long_minmax_index (const gsl_matrix_long * m, size_t * imin, size_t * jmin, size_t * imax, size_t * jmax); +- +-int gsl_matrix_long_equal (const gsl_matrix_long * a, const gsl_matrix_long * b); +- +-int gsl_matrix_long_isnull (const gsl_matrix_long * m); +-int gsl_matrix_long_ispos (const gsl_matrix_long * m); +-int gsl_matrix_long_isneg (const gsl_matrix_long * m); +-int gsl_matrix_long_isnonneg (const gsl_matrix_long * m); +- +-int gsl_matrix_long_add (gsl_matrix_long * a, const gsl_matrix_long * b); +-int gsl_matrix_long_sub (gsl_matrix_long * a, const gsl_matrix_long * b); +-int gsl_matrix_long_mul_elements (gsl_matrix_long * a, const gsl_matrix_long * b); +-int gsl_matrix_long_div_elements (gsl_matrix_long * a, const gsl_matrix_long * b); +-int gsl_matrix_long_scale (gsl_matrix_long * a, const double x); +-int gsl_matrix_long_add_constant (gsl_matrix_long * a, const double x); +-int gsl_matrix_long_add_diagonal (gsl_matrix_long * a, const double x); +- +-/***********************************************************************/ +-/* The functions below are obsolete */ +-/***********************************************************************/ +-int gsl_matrix_long_get_row(gsl_vector_long * v, const gsl_matrix_long * m, const size_t i); +-int gsl_matrix_long_get_col(gsl_vector_long * v, const gsl_matrix_long * m, const size_t j); +-int gsl_matrix_long_set_row(gsl_matrix_long * m, const size_t i, const gsl_vector_long * v); +-int gsl_matrix_long_set_col(gsl_matrix_long * m, const size_t j, const gsl_vector_long * v); +-/***********************************************************************/ +- +-/* inline functions if you are using GCC */ +- +-INLINE_DECL long gsl_matrix_long_get(const gsl_matrix_long * m, const size_t i, const size_t j); +-INLINE_DECL void gsl_matrix_long_set(gsl_matrix_long * m, const size_t i, const size_t j, const long x); +-INLINE_DECL long * gsl_matrix_long_ptr(gsl_matrix_long * m, const size_t i, const size_t j); +-INLINE_DECL const long * gsl_matrix_long_const_ptr(const gsl_matrix_long * m, const size_t i, const size_t j); +- +-#ifdef HAVE_INLINE +-INLINE_FUN +-long +-gsl_matrix_long_get(const gsl_matrix_long * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0) ; +- } +- } +-#endif +- return m->data[i * m->tda + j] ; +-} +- +-INLINE_FUN +-void +-gsl_matrix_long_set(gsl_matrix_long * m, const size_t i, const size_t j, const long x) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_VOID("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_VOID("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- m->data[i * m->tda + j] = x ; +-} +- +-INLINE_FUN +-long * +-gsl_matrix_long_ptr(gsl_matrix_long * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (long *) (m->data + (i * m->tda + j)) ; +-} +- +-INLINE_FUN +-const long * +-gsl_matrix_long_const_ptr(const gsl_matrix_long * m, const size_t i, const size_t j) +-{ +-#if GSL_RANGE_CHECK +- if (GSL_RANGE_COND(1)) +- { +- if (i >= m->size1) +- { +- GSL_ERROR_NULL("first index out of range", GSL_EINVAL) ; +- } +- else if (j >= m->size2) +- { +- GSL_ERROR_NULL("second index out of range", GSL_EINVAL) ; +- } +- } +-#endif +- return (const long *) (m->data + (i * m->tda + j)) ; +-} +- +-#endif +- +-__END_DECLS +- +-#endif /* __GSL_MATRIX_LONG_H__ */ +Index: ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk (revision 14078) ++++ ../trunk-jpl/src/android/ISSM/jni/gsllib/Android.mk (revision 14079) +@@ -2,7 +2,7 @@ + include $(CLEAR_VARS) + LOCAL_MODULE := libgsl + LOCAL_SRC_FILES := libsgsl.a +-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include/gsl ++LOCAL_EXPORT_C_INCLUDES := $(ISSM_DIR)/externalpackages/gsl/install/include/gsl/ + include $(PREBUILT_STATIC_LIBRARY) + + #include $(CLEAR_VARS) Index: /issm/oecreview/Archive/14064-14311/ISSM-14079-14080.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14079-14080.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14079-14080.diff (revision 14312) @@ -0,0 +1,995 @@ +Index: ../trunk-jpl/src/android/ISSM/project.properties +=================================================================== +--- ../trunk-jpl/src/android/ISSM/project.properties (revision 14079) ++++ ../trunk-jpl/src/android/ISSM/project.properties (revision 14080) +@@ -11,4 +11,4 @@ + #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + + # Project target. +-target=android-15 ++target=Google Inc.:Google APIs:16 +Index: ../trunk-jpl/src/android/ISSM_Visual/AndroidManifest.xml +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/AndroidManifest.xml (revision 14079) ++++ ../trunk-jpl/src/android/ISSM_Visual/AndroidManifest.xml (revision 14080) +@@ -1,5 +1,5 @@ + + +Index: ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/ISSMVisual.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/ISSMVisual.java (revision 14079) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/ISSMVisual.java (revision 14080) +@@ -1,95 +0,0 @@ +-package com.example.issm_visual; +- +- +-import android.app.Activity; +-import android.content.DialogInterface.OnClickListener; +-import android.opengl.GLSurfaceView; +-import android.os.Bundle; +-import android.view.Menu; +-import android.view.View; +-import android.widget.Button; +-import android.widget.FrameLayout; +-import android.widget.SeekBar; +-import android.widget.SeekBar.OnSeekBarChangeListener; +-import android.widget.TextView; +- +-public class ISSMVisual extends Activity implements OnSeekBarChangeListener +-{ +- private SeekBar bar; +- private TextView /*txtStatus,*/ txtValue; +- private GLSurfaceView mGLView; +- private FrameLayout frame; +- +- @Override +- public void onCreate(Bundle savedInstanceState) +- { +- super.onCreate(savedInstanceState); +- setContentView(R.layout.activity_issmvisual); +- +- bar = (SeekBar)findViewById(R.id.seekBar); // make seekbar object +- bar.setOnSeekBarChangeListener(this); // set seekbar listener +- txtValue = (TextView)findViewById(R.id.value); +- Button reset = (Button)findViewById(R.id.button1); +- reset.setOnClickListener(new View.OnClickListener() +- { +- public void onClick(View v) +- { +- frame.removeView(mGLView); +- mGLView = new MyGLSurfaceView(ISSMVisual.this); +- frame.addView(mGLView); +- } +- }); +- //txtStatus = (TextView)findViewById(R.id.status); +- +- mGLView = new MyGLSurfaceView(this); +- frame = (FrameLayout)findViewById(R.id.frame); +- frame.addView(mGLView); +- } +- public void onProgressChanged(SeekBar seekBar, int val, +- boolean fromUser) +- { +- // change progress text label with current Seekbar value +- txtValue.setText("alpha value = " + val); +- //txtStatus.setText("Status: changing"); +- } +- +- public void onStartTrackingTouch(SeekBar seekBar) {/*txtStatus.setText("Status: Starting to track touch");*/} +- +- public void onStopTrackingTouch(SeekBar seekBar) +- { +- seekBar.setSecondaryProgress(seekBar.getProgress()); // set the shade of the previous value. +- +- //txtStatus.setText("Status: Ended tracking touch"); +- frame.removeView(mGLView); +- mGLView = new MyGLSurfaceView(this); +- frame.addView(mGLView); +- } +- +- @Override +- protected void onPause() +- { +- super.onPause(); +- // The following call pauses the rendering thread. +- // If your OpenGL application is memory intensive, +- // you should consider de-allocating objects that +- // consume significant memory here. +- mGLView.onPause(); +- } +- +- @Override +- protected void onResume() +- { +- super.onResume(); +- // The following call resumes a paused rendering thread. +- // If you de-allocated graphic objects for onPause() +- // this is a good place to re-allocate them. +- mGLView.onResume(); +- } +- +- @Override +- public boolean onCreateOptionsMenu(Menu menu) +- { +- getMenuInflater().inflate(R.menu.activity_issmvisual, menu); +- return true; +- } +-} +Index: ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLRenderer.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLRenderer.java (revision 14079) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLRenderer.java (revision 14080) +@@ -1,294 +0,0 @@ +-/* +- * Copyright (C) 2012 The Android Open Source Project +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +- +-package com.example.issm_visual; +-import java.nio.ByteBuffer; +-import java.nio.ByteOrder; +-import java.nio.FloatBuffer; +- +-import javax.microedition.khronos.egl.EGLConfig; +-import javax.microedition.khronos.opengles.GL10; +- +-import android.opengl.GLES20; +-import android.opengl.GLSurfaceView; +-import android.opengl.Matrix; +- +-public class MyGLRenderer implements GLSurfaceView.Renderer +-{ +- public volatile float mAngle; +- +- /** +- * Store the model matrix. This matrix is used to move models from object space (where each model can be thought +- * of being located at the center of the universe) to world space. +- */ +- private float[][] mModelMatrix; +- +- /** +- * Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space; +- * it positions things relative to our eye. +- */ +- private float[][] mViewMatrix; +- +- /** Store the projection matrix. This is used to project the scene onto a 2D viewport. */ +- private float[][] mProjectionMatrix; +- +- /** Allocate storage for the final combined matrix. This will be passed into the shader program. */ +- private float[][] mMVPMatrix; +- +- /** This will be used to pass in the transformation matrix. */ +- private int mMatrixHandle; +- +- private FloatBuffer[] triangleVert; +- +- private float[][] triangleData2DArr; +- +- private int mPositionHandle; +- +- private int mColorHandle; +- +- /** How many bytes per float. */ +- private final int mBytesPerFloat = 4; +- +- /** How many elements per vertex. */ +- private final int mStrideBytes = 7 * mBytesPerFloat; +- +- /** Offset of the position data. */ +- private final int mPositionOffset = 0; +- +- /** Size of the position data in elements. */ +- private final int mPositionDataSize = 3; +- +- /** Offset of the color data. */ +- private final int mColorOffset = 3; +- +- /** Size of the color data in elements. */ +- private final int mColorDataSize = 4; +- +- public MyGLRenderer(float[][] vertices) +- { +- triangleData2DArr = new float[vertices.length][21]; +- triangleVert = new FloatBuffer[vertices.length]; +- +- for (int i = 0; i < vertices.length; i++) +- { +- for (int j = 0; j < 21; j++) +- triangleData2DArr[i][j] = vertices[i][j]; +- } +- +- // initialize vertex byte buffer for shape coordinates +- for (int i = 0; i < vertices.length; i++) +- { +- triangleVert[i] = ByteBuffer.allocateDirect(triangleData2DArr[i].length * mBytesPerFloat) +- .order(ByteOrder.nativeOrder()).asFloatBuffer(); +- triangleVert[i].put(triangleData2DArr[i]).position(0); +- } +- } +- +- public void onSurfaceCreated(GL10 unused, EGLConfig config) +- { +- // Set the background frame color +- GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); +- +- // Position the eye behind the origin. +- final float eyeX = 0.0f; +- final float eyeY = 0.0f; +- final float eyeZ = 1.5f; +- +- // We are looking toward the distance +- final float lookX = 0.0f; +- final float lookY = 0.0f; +- final float lookZ = -5.0f; +- +- // Set our up vector. This is where our head would be pointing were we holding the camera. +- final float upX = 0.0f; +- final float upY = 1.0f; +- final float upZ = 0.0f; +- +- // Set the view matrix. This matrix can be said to represent the camera position. +- // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and +- // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose. +- mViewMatrix = new float[triangleVert.length][16]; +- +- for (int i = 0; i < triangleVert.length; i++) +- Matrix.setLookAtM(mViewMatrix[i], 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ); +- +- final String vertexShader = +- "uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix. +- + "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. +- + "attribute vec4 a_Color; \n" // Per-vertex color information we will pass in. +- + "varying vec4 v_Color; \n" // This will be passed into the fragment shader. +- + "void main() \n" // The entry point for our vertex shader. +- + "{ \n" +- + " v_Color = a_Color; \n" // Pass the color through to the fragment shader. +- // It will be interpolated across the triangle. +- + " gl_Position = u_MVPMatrix \n" // gl_Position is a special variable used to store the final position. +- + " * a_Position; \n" // Multiply the vertex by the matrix to get the final point in +- + "} \n"; // normalized screen coordinates. +- +- final String fragmentShader = +- "precision mediump float; \n" // Set the default precision to medium. We don't need as high of a // precision in the fragment shader. +- + "varying vec4 v_Color; \n" // This is the color from the vertex shader interpolated across the +- // triangle per fragment. +- + "void main() \n" // The entry point for our fragment shader. +- + "{ \n" +- + " gl_FragColor = v_Color; \n" // Pass the color directly through the pipeline. +- + "} \n"; +- +- +- int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); +- // Pass in the shader source. +- GLES20.glShaderSource(vertexShaderHandle, vertexShader); +- +- // Compile the shader. +- GLES20.glCompileShader(vertexShaderHandle); +- +- // Get the compilation status. +- final int[] compileStatus1 = new int[1]; +- GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus1, 0); +- +- // If the compilation failed, delete the shader. +- if (compileStatus1[0] == 0) +- { +- GLES20.glDeleteShader(vertexShaderHandle); +- vertexShaderHandle = 0; +- } +- +- +- int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); +- // Pass in the shader source. +- GLES20.glShaderSource(fragmentShaderHandle, fragmentShader); +- +- // Compile the shader. +- GLES20.glCompileShader(fragmentShaderHandle); +- +- // Get the compilation status. +- final int[] compileStatus2 = new int[1]; +- GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus2, 0); +- +- // If the compilation failed, delete the shader. +- if (compileStatus2[0] == 0) +- { +- GLES20.glDeleteShader(fragmentShaderHandle); +- fragmentShaderHandle = 0; +- } +- +- +- int mProgram = GLES20.glCreateProgram(); +- // Bind the vertex shader to the program. +- GLES20.glAttachShader(mProgram, vertexShaderHandle); +- +- // Bind the fragment shader to the program. +- GLES20.glAttachShader(mProgram, fragmentShaderHandle); +- +- // Bind attributes +- GLES20.glBindAttribLocation(mProgram, 0, "a_Position"); +- GLES20.glBindAttribLocation(mProgram, 1, "a_Color"); +- +- // Link the two shaders together into a program. +- GLES20.glLinkProgram(mProgram); +- +- // Get the link status. +- final int[] linkStatus = new int[1]; +- GLES20.glGetProgramiv(mProgram, GLES20.GL_LINK_STATUS, linkStatus, 0); +- +- // If the link failed, delete the program. +- if (linkStatus[0] == 0) +- { +- GLES20.glDeleteProgram(mProgram); +- mProgram = 0; +- } +- +- for (int i = 0; i < triangleVert.length; i++) +- { +- mMatrixHandle = GLES20.glGetUniformLocation(mProgram, "u_MVPMatrix"); +- mPositionHandle = GLES20.glGetAttribLocation(mProgram, "a_Position"); +- mColorHandle = GLES20.glGetAttribLocation(mProgram, "a_Color"); +- } +- +- // Add program to OpenGL environment +- GLES20.glUseProgram(mProgram); +- } +- +- public void onSurfaceChanged(GL10 unused, int width, int height) +- { +- // Adjust the viewport based on geometry changes, +- // such as screen rotation +- GLES20.glViewport(0, 0, width, height); +- +- // Create a new perspective projection matrix. The height will stay the same +- // while the width will vary as per aspect ratio. +- final float ratio = (float) width / height; +- +- mProjectionMatrix = new float[triangleVert.length][16]; +- for (int i = 0; i < triangleVert.length; i++) +- Matrix.frustumM(mProjectionMatrix[i], 0, -ratio*1.4f, ratio*1.4f, -1.4f, 1.4f, 1.4f, 14f); +- } +- +- public void onDrawFrame(GL10 glUnused) +- { +- // Draw background color +- GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); +- +- mModelMatrix = new float[triangleVert.length][16]; +- // Draw the triangle facing straight on. +- for (int i = 0; i < triangleVert.length; i++) +- Matrix.setIdentityM(mModelMatrix[i], 0); +- +- mMVPMatrix = new float[triangleVert.length][16]; +- draw(triangleVert); +- +- } +- +- private void draw(final FloatBuffer[] aTriangleBuffer) +- { +- for (int i = 0; i < aTriangleBuffer.length; i++) +- { +- // Pass in the position information +- aTriangleBuffer[i].position(mPositionOffset); +- GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false, +- mStrideBytes, aTriangleBuffer[i]); +- +- GLES20.glEnableVertexAttribArray(mPositionHandle); +- +- +- // Pass in the color information +- aTriangleBuffer[i].position(mColorOffset); +- GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false, +- mStrideBytes, aTriangleBuffer[i]); +- +- GLES20.glEnableVertexAttribArray(mColorHandle); +- +- Matrix.setRotateM(mModelMatrix[i], 0, mAngle, 0, 0, -1.0f); +- +- // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix +- // (which currently contains model * view). +- Matrix.multiplyMM(mMVPMatrix[i], 0, mViewMatrix[i], 0, mModelMatrix[i], 0); +- +- // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix +- // (which now contains model * view * projection). +- Matrix.multiplyMM(mMVPMatrix[i], 0, mProjectionMatrix[i], 0, mMVPMatrix[i], 0); +- +- GLES20.glUniformMatrix4fv(mMatrixHandle, 1, false, mMVPMatrix[i], 0); +- +- // Draw the triangle +- GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3); +- +- // Disable vertex array +- GLES20.glDisableVertexAttribArray(mPositionHandle); +- } +- } +- +-} +Index: ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLSurfaceView.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLSurfaceView.java (revision 14079) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLSurfaceView.java (revision 14080) +@@ -1,82 +0,0 @@ +-package com.example.issm_visual; +- +-import android.content.Context; +-import android.opengl.GLSurfaceView; +-import android.view.MotionEvent; +- +- +-class MyGLSurfaceView extends GLSurfaceView +-{ +- private MyGLRenderer mRend; +- public MyGLSurfaceView(Context context) +- { +- super(context); +- +- // Create an OpenGL ES 2.0 context. +- setEGLContextClientVersion(2); +- +- final int NMAX_TRIANGLES = 2000; +- final int MAX_VERTICES = 21; +- +- float f[][] = new float[NMAX_TRIANGLES][MAX_VERTICES]; +- int n, random; +- for (int i = 0; i < f.length; i++) +- { +- for (int j = 0; j < MAX_VERTICES; j++) +- { +- if (j == 6 || j == 13 || j == 20) continue; +- n = 1; +- random = (int)(Math.floor((Math.random()*10)+1)); +- if (random <= 5) n = -1; +- +- f[i][j] = (float)(Math.random()*n); +- } +- } +- +- mRend = new MyGLRenderer(f); +- +- // Set the Renderer for drawing on the GLSurfaceView +- setRenderer(mRend); +- +- // Render the view only when there is a change in the drawing data +- setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); +- } +- +- private final float TOUCH_SCALE_FACTOR = 180.0f / 320; +- private float mPreviousX; +- +- private float mPreviousY; +- @Override +- public boolean onTouchEvent(MotionEvent e) { +- // MotionEvent reports input details from the touch screen +- // and other input controls. In this case, you are only +- // interested in events where the touch position changed. +- +- float x = e.getX(); +- float y = e.getY(); +- +- switch (e.getAction()) { +- case MotionEvent.ACTION_MOVE: +- +- float dx = x - mPreviousX; +- float dy = y - mPreviousY; +- +- // reverse direction of rotation above the mid-line +- if (y > getHeight() / 2) { +- dx = dx * -1 ; +- } +- +- // reverse direction of rotation to left of the mid-line +- if (x < getWidth() / 2) { +- dy = dy * -1 ; +- } +- +- mRend.mAngle += (dx + dy) * TOUCH_SCALE_FACTOR; // = 180.0f / 320 +- requestRender(); +- } +- +- mPreviousX = x; +- mPreviousY = y; +- return true; +- } +-} +\ No newline at end of file +Index: ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/ISSMVisual.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/ISSMVisual.java (revision 0) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/ISSMVisual.java (revision 14080) +@@ -0,0 +1,95 @@ ++package gov.nasa.jpl.issm.visual; ++ ++ ++import android.app.Activity; ++import android.content.DialogInterface.OnClickListener; ++import android.opengl.GLSurfaceView; ++import android.os.Bundle; ++import android.view.Menu; ++import android.view.View; ++import android.widget.Button; ++import android.widget.FrameLayout; ++import android.widget.SeekBar; ++import android.widget.SeekBar.OnSeekBarChangeListener; ++import android.widget.TextView; ++ ++public class ISSMVisual extends Activity implements OnSeekBarChangeListener ++{ ++ private SeekBar bar; ++ private TextView /*txtStatus,*/ txtValue; ++ private GLSurfaceView mGLView; ++ private FrameLayout frame; ++ ++ @Override ++ public void onCreate(Bundle savedInstanceState) ++ { ++ super.onCreate(savedInstanceState); ++ setContentView(R.layout.activity_issmvisual); ++ ++ bar = (SeekBar)findViewById(R.id.seekBar); // make seekbar object ++ bar.setOnSeekBarChangeListener(this); // set seekbar listener ++ txtValue = (TextView)findViewById(R.id.value); ++ Button reset = (Button)findViewById(R.id.button1); ++ reset.setOnClickListener(new View.OnClickListener() ++ { ++ public void onClick(View v) ++ { ++ frame.removeView(mGLView); ++ mGLView = new MyGLSurfaceView(ISSMVisual.this); ++ frame.addView(mGLView); ++ } ++ }); ++ //txtStatus = (TextView)findViewById(R.id.status); ++ ++ mGLView = new MyGLSurfaceView(this); ++ frame = (FrameLayout)findViewById(R.id.frame); ++ frame.addView(mGLView); ++ } ++ public void onProgressChanged(SeekBar seekBar, int val, ++ boolean fromUser) ++ { ++ // change progress text label with current Seekbar value ++ txtValue.setText("alpha value = " + val); ++ //txtStatus.setText("Status: changing"); ++ } ++ ++ public void onStartTrackingTouch(SeekBar seekBar) {/*txtStatus.setText("Status: Starting to track touch");*/} ++ ++ public void onStopTrackingTouch(SeekBar seekBar) ++ { ++ seekBar.setSecondaryProgress(seekBar.getProgress()); // set the shade of the previous value. ++ ++ //txtStatus.setText("Status: Ended tracking touch"); ++ frame.removeView(mGLView); ++ mGLView = new MyGLSurfaceView(this); ++ frame.addView(mGLView); ++ } ++ ++ @Override ++ protected void onPause() ++ { ++ super.onPause(); ++ // The following call pauses the rendering thread. ++ // If your OpenGL application is memory intensive, ++ // you should consider de-allocating objects that ++ // consume significant memory here. ++ mGLView.onPause(); ++ } ++ ++ @Override ++ protected void onResume() ++ { ++ super.onResume(); ++ // The following call resumes a paused rendering thread. ++ // If you de-allocated graphic objects for onPause() ++ // this is a good place to re-allocate them. ++ mGLView.onResume(); ++ } ++ ++ @Override ++ public boolean onCreateOptionsMenu(Menu menu) ++ { ++ getMenuInflater().inflate(R.menu.activity_issmvisual, menu); ++ return true; ++ } ++} +Index: ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLRenderer.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLRenderer.java (revision 0) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLRenderer.java (revision 14080) +@@ -0,0 +1,294 @@ ++/* ++ * Copyright (C) 2012 The Android Open Source Project ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package gov.nasa.jpl.issm.visual; ++import java.nio.ByteBuffer; ++import java.nio.ByteOrder; ++import java.nio.FloatBuffer; ++ ++import javax.microedition.khronos.egl.EGLConfig; ++import javax.microedition.khronos.opengles.GL10; ++ ++import android.opengl.GLES20; ++import android.opengl.GLSurfaceView; ++import android.opengl.Matrix; ++ ++public class MyGLRenderer implements GLSurfaceView.Renderer ++{ ++ public volatile float mAngle; ++ ++ /** ++ * Store the model matrix. This matrix is used to move models from object space (where each model can be thought ++ * of being located at the center of the universe) to world space. ++ */ ++ private float[][] mModelMatrix; ++ ++ /** ++ * Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space; ++ * it positions things relative to our eye. ++ */ ++ private float[][] mViewMatrix; ++ ++ /** Store the projection matrix. This is used to project the scene onto a 2D viewport. */ ++ private float[][] mProjectionMatrix; ++ ++ /** Allocate storage for the final combined matrix. This will be passed into the shader program. */ ++ private float[][] mMVPMatrix; ++ ++ /** This will be used to pass in the transformation matrix. */ ++ private int mMatrixHandle; ++ ++ private FloatBuffer[] triangleVert; ++ ++ private float[][] triangleData2DArr; ++ ++ private int mPositionHandle; ++ ++ private int mColorHandle; ++ ++ /** How many bytes per float. */ ++ private final int mBytesPerFloat = 4; ++ ++ /** How many elements per vertex. */ ++ private final int mStrideBytes = 7 * mBytesPerFloat; ++ ++ /** Offset of the position data. */ ++ private final int mPositionOffset = 0; ++ ++ /** Size of the position data in elements. */ ++ private final int mPositionDataSize = 3; ++ ++ /** Offset of the color data. */ ++ private final int mColorOffset = 3; ++ ++ /** Size of the color data in elements. */ ++ private final int mColorDataSize = 4; ++ ++ public MyGLRenderer(float[][] vertices) ++ { ++ triangleData2DArr = new float[vertices.length][21]; ++ triangleVert = new FloatBuffer[vertices.length]; ++ ++ for (int i = 0; i < vertices.length; i++) ++ { ++ for (int j = 0; j < 21; j++) ++ triangleData2DArr[i][j] = vertices[i][j]; ++ } ++ ++ // initialize vertex byte buffer for shape coordinates ++ for (int i = 0; i < vertices.length; i++) ++ { ++ triangleVert[i] = ByteBuffer.allocateDirect(triangleData2DArr[i].length * mBytesPerFloat) ++ .order(ByteOrder.nativeOrder()).asFloatBuffer(); ++ triangleVert[i].put(triangleData2DArr[i]).position(0); ++ } ++ } ++ ++ public void onSurfaceCreated(GL10 unused, EGLConfig config) ++ { ++ // Set the background frame color ++ GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); ++ ++ // Position the eye behind the origin. ++ final float eyeX = 0.0f; ++ final float eyeY = 0.0f; ++ final float eyeZ = 1.5f; ++ ++ // We are looking toward the distance ++ final float lookX = 0.0f; ++ final float lookY = 0.0f; ++ final float lookZ = -5.0f; ++ ++ // Set our up vector. This is where our head would be pointing were we holding the camera. ++ final float upX = 0.0f; ++ final float upY = 1.0f; ++ final float upZ = 0.0f; ++ ++ // Set the view matrix. This matrix can be said to represent the camera position. ++ // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and ++ // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose. ++ mViewMatrix = new float[triangleVert.length][16]; ++ ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.setLookAtM(mViewMatrix[i], 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ); ++ ++ final String vertexShader = ++ "uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix. ++ + "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. ++ + "attribute vec4 a_Color; \n" // Per-vertex color information we will pass in. ++ + "varying vec4 v_Color; \n" // This will be passed into the fragment shader. ++ + "void main() \n" // The entry point for our vertex shader. ++ + "{ \n" ++ + " v_Color = a_Color; \n" // Pass the color through to the fragment shader. ++ // It will be interpolated across the triangle. ++ + " gl_Position = u_MVPMatrix \n" // gl_Position is a special variable used to store the final position. ++ + " * a_Position; \n" // Multiply the vertex by the matrix to get the final point in ++ + "} \n"; // normalized screen coordinates. ++ ++ final String fragmentShader = ++ "precision mediump float; \n" // Set the default precision to medium. We don't need as high of a // precision in the fragment shader. ++ + "varying vec4 v_Color; \n" // This is the color from the vertex shader interpolated across the ++ // triangle per fragment. ++ + "void main() \n" // The entry point for our fragment shader. ++ + "{ \n" ++ + " gl_FragColor = v_Color; \n" // Pass the color directly through the pipeline. ++ + "} \n"; ++ ++ ++ int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); ++ // Pass in the shader source. ++ GLES20.glShaderSource(vertexShaderHandle, vertexShader); ++ ++ // Compile the shader. ++ GLES20.glCompileShader(vertexShaderHandle); ++ ++ // Get the compilation status. ++ final int[] compileStatus1 = new int[1]; ++ GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus1, 0); ++ ++ // If the compilation failed, delete the shader. ++ if (compileStatus1[0] == 0) ++ { ++ GLES20.glDeleteShader(vertexShaderHandle); ++ vertexShaderHandle = 0; ++ } ++ ++ ++ int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); ++ // Pass in the shader source. ++ GLES20.glShaderSource(fragmentShaderHandle, fragmentShader); ++ ++ // Compile the shader. ++ GLES20.glCompileShader(fragmentShaderHandle); ++ ++ // Get the compilation status. ++ final int[] compileStatus2 = new int[1]; ++ GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus2, 0); ++ ++ // If the compilation failed, delete the shader. ++ if (compileStatus2[0] == 0) ++ { ++ GLES20.glDeleteShader(fragmentShaderHandle); ++ fragmentShaderHandle = 0; ++ } ++ ++ ++ int mProgram = GLES20.glCreateProgram(); ++ // Bind the vertex shader to the program. ++ GLES20.glAttachShader(mProgram, vertexShaderHandle); ++ ++ // Bind the fragment shader to the program. ++ GLES20.glAttachShader(mProgram, fragmentShaderHandle); ++ ++ // Bind attributes ++ GLES20.glBindAttribLocation(mProgram, 0, "a_Position"); ++ GLES20.glBindAttribLocation(mProgram, 1, "a_Color"); ++ ++ // Link the two shaders together into a program. ++ GLES20.glLinkProgram(mProgram); ++ ++ // Get the link status. ++ final int[] linkStatus = new int[1]; ++ GLES20.glGetProgramiv(mProgram, GLES20.GL_LINK_STATUS, linkStatus, 0); ++ ++ // If the link failed, delete the program. ++ if (linkStatus[0] == 0) ++ { ++ GLES20.glDeleteProgram(mProgram); ++ mProgram = 0; ++ } ++ ++ for (int i = 0; i < triangleVert.length; i++) ++ { ++ mMatrixHandle = GLES20.glGetUniformLocation(mProgram, "u_MVPMatrix"); ++ mPositionHandle = GLES20.glGetAttribLocation(mProgram, "a_Position"); ++ mColorHandle = GLES20.glGetAttribLocation(mProgram, "a_Color"); ++ } ++ ++ // Add program to OpenGL environment ++ GLES20.glUseProgram(mProgram); ++ } ++ ++ public void onSurfaceChanged(GL10 unused, int width, int height) ++ { ++ // Adjust the viewport based on geometry changes, ++ // such as screen rotation ++ GLES20.glViewport(0, 0, width, height); ++ ++ // Create a new perspective projection matrix. The height will stay the same ++ // while the width will vary as per aspect ratio. ++ final float ratio = (float) width / height; ++ ++ mProjectionMatrix = new float[triangleVert.length][16]; ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.frustumM(mProjectionMatrix[i], 0, -ratio*1.4f, ratio*1.4f, -1.4f, 1.4f, 1.4f, 14f); ++ } ++ ++ public void onDrawFrame(GL10 glUnused) ++ { ++ // Draw background color ++ GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); ++ ++ mModelMatrix = new float[triangleVert.length][16]; ++ // Draw the triangle facing straight on. ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.setIdentityM(mModelMatrix[i], 0); ++ ++ mMVPMatrix = new float[triangleVert.length][16]; ++ draw(triangleVert); ++ ++ } ++ ++ private void draw(final FloatBuffer[] aTriangleBuffer) ++ { ++ for (int i = 0; i < aTriangleBuffer.length; i++) ++ { ++ // Pass in the position information ++ aTriangleBuffer[i].position(mPositionOffset); ++ GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false, ++ mStrideBytes, aTriangleBuffer[i]); ++ ++ GLES20.glEnableVertexAttribArray(mPositionHandle); ++ ++ ++ // Pass in the color information ++ aTriangleBuffer[i].position(mColorOffset); ++ GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false, ++ mStrideBytes, aTriangleBuffer[i]); ++ ++ GLES20.glEnableVertexAttribArray(mColorHandle); ++ ++ Matrix.setRotateM(mModelMatrix[i], 0, mAngle, 0, 0, -1.0f); ++ ++ // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix ++ // (which currently contains model * view). ++ Matrix.multiplyMM(mMVPMatrix[i], 0, mViewMatrix[i], 0, mModelMatrix[i], 0); ++ ++ // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix ++ // (which now contains model * view * projection). ++ Matrix.multiplyMM(mMVPMatrix[i], 0, mProjectionMatrix[i], 0, mMVPMatrix[i], 0); ++ ++ GLES20.glUniformMatrix4fv(mMatrixHandle, 1, false, mMVPMatrix[i], 0); ++ ++ // Draw the triangle ++ GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3); ++ ++ // Disable vertex array ++ GLES20.glDisableVertexAttribArray(mPositionHandle); ++ } ++ } ++ ++} +Index: ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLSurfaceView.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLSurfaceView.java (revision 0) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/MyGLSurfaceView.java (revision 14080) +@@ -0,0 +1,82 @@ ++package gov.nasa.jpl.issm.visual; ++ ++import android.content.Context; ++import android.opengl.GLSurfaceView; ++import android.view.MotionEvent; ++ ++ ++class MyGLSurfaceView extends GLSurfaceView ++{ ++ private MyGLRenderer mRend; ++ public MyGLSurfaceView(Context context) ++ { ++ super(context); ++ ++ // Create an OpenGL ES 2.0 context. ++ setEGLContextClientVersion(2); ++ ++ final int NMAX_TRIANGLES = 2000; ++ final int MAX_VERTICES = 21; ++ ++ float f[][] = new float[NMAX_TRIANGLES][MAX_VERTICES]; ++ int n, random; ++ for (int i = 0; i < f.length; i++) ++ { ++ for (int j = 0; j < MAX_VERTICES; j++) ++ { ++ if (j == 6 || j == 13 || j == 20) continue; ++ n = 1; ++ random = (int)(Math.floor((Math.random()*10)+1)); ++ if (random <= 5) n = -1; ++ ++ f[i][j] = (float)(Math.random()*n); ++ } ++ } ++ ++ mRend = new MyGLRenderer(f); ++ ++ // Set the Renderer for drawing on the GLSurfaceView ++ setRenderer(mRend); ++ ++ // Render the view only when there is a change in the drawing data ++ setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); ++ } ++ ++ private final float TOUCH_SCALE_FACTOR = 180.0f / 320; ++ private float mPreviousX; ++ ++ private float mPreviousY; ++ @Override ++ public boolean onTouchEvent(MotionEvent e) { ++ // MotionEvent reports input details from the touch screen ++ // and other input controls. In this case, you are only ++ // interested in events where the touch position changed. ++ ++ float x = e.getX(); ++ float y = e.getY(); ++ ++ switch (e.getAction()) { ++ case MotionEvent.ACTION_MOVE: ++ ++ float dx = x - mPreviousX; ++ float dy = y - mPreviousY; ++ ++ // reverse direction of rotation above the mid-line ++ if (y > getHeight() / 2) { ++ dx = dx * -1 ; ++ } ++ ++ // reverse direction of rotation to left of the mid-line ++ if (x < getWidth() / 2) { ++ dy = dy * -1 ; ++ } ++ ++ mRend.mAngle += (dx + dy) * TOUCH_SCALE_FACTOR; // = 180.0f / 320 ++ requestRender(); ++ } ++ ++ mPreviousX = x; ++ mPreviousY = y; ++ return true; ++ } ++} +\ No newline at end of file Index: /issm/oecreview/Archive/14064-14311/ISSM-14080-14081.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14080-14081.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14080-14081.diff (revision 14312) @@ -0,0 +1,183 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14080) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14081) +@@ -3,57 +3,83 @@ + #include "../../../c/issm.h" + #include + #include +-/////////////////////////////////////////////////////////////////////////////////////////// ++ + namespace com_example_issm + { ++ /*Global variables{{{*/ + fac* f; + FemModel *fm; +-//------------------------------------------------------------------------------------ +- jint initilize(JNIEnv *env, jclass clazz, jstring file) ++ /*}}}*/ ++ jint initialize(JNIEnv *env, jclass clazz, jstring jsolution_type, jstring jabsfile, jstring jrelfile) /*{{{*/ + { +- char *nativefile = (char*)env->GetStringUTFChars(file,0); ++ ++ /*arguments to constructor: */ ++ int argc; //arguments to constructor. ++ char** argv = NULL; ++ COMM communicator = 1; //fake communicator for constructor ++ const char* issmname = "issm.exe"; ++ char *solution_type = NULL; ++ char *absfile = NULL; ++ char *relfile = NULL; + ++ /*retrieve from java machine: */ ++ solution_type = (char*)env->GetStringUTFChars(jsolution_type,0); ++ absfile = (char*)env->GetStringUTFChars(jabsfile,0); ++ relfile = (char*)env->GetStringUTFChars(jrelfile,0); ++ ++ /*creat arguments to call constructor for FemModel: */ ++ argc=4; ++ argv=(char**)malloc(argc*sizeof(char*)); ++ argv[0]=(char*)issmname; ++ argv[1]=solution_type; ++ argv[2]=absfile; ++ argv[3]=relfile; ++ + f = new fac(); + +- //call Model constructor passing in infile as File Descriptor parameter. +- fm = new FemModel(nativefile); ++ /*call Model constructor passing in infile as File Descriptor parameter.*/ ++ fm = new FemModel(argc,argv,communicator); + +- env->ReleaseStringUTFChars(file, nativefile); //must realease the char* ++ /*release strings: */ ++ env->ReleaseStringUTFChars(jsolution_type, solution_type); //must realease the char* ++ env->ReleaseStringUTFChars(jabsfile, absfile); //must realease the char* ++ env->ReleaseStringUTFChars(jrelfile, relfile); //must realease the char* ++ ++ /*figure out size of solution: */ + //jint size = (jint) fm->bufferSize(); +- //return size; ++ jint size =7; ++ ++ return size; + +- return 0; //return 0 for now. + } +-//------------------------------------------------------------------------------------ +- //fill out the first two slots, extract the same way in java using get(int position) +- void solve(JNIEnv *env, jclass clazz , jint alpha, jobject buf) ++ /*}}}*/ ++ void solve(JNIEnv *env, jclass clazz , jint alpha, jobject buf) /*{{{*/ + { ++ /*fill out the first two slots, extract the same way in java using get(int position)*/ + jdouble *dBuf = (jdouble *)env->GetDirectBufferAddress(buf); + + //pass bBuff to fem model to allocate data + // fm -> solve(dBuf, alpha); + +- } +-//------------------------------------------------------------------------------------ +- jlong factorial(JNIEnv *env, jclass clazz, jlong n) ++ }/*}}}*/ ++ jlong factorial(JNIEnv *env, jclass clazz, jlong n) /*{{{*/ + { + if( f != NULL) + return (jlong) (f->factorial(n)); + return 0; + } +- +-//------------------------------------------------------------------------------------ +- static JNINativeMethod method_table[] = ++ /*}}}*/ ++ static JNINativeMethod method_table[] = /*{{{*/ + { + {"fac" , "(J)J" , (void *) factorial}, +- {"createISSMModel" ,"(Ljava/lang/String;)I" , (void *) initilize}, ++ {"createISSMModel" ,"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I" , (void *) initialize}, + {"processBuffer", "(ILjava/nio/DoubleBuffer;)V", (void *) solve} + }; ++ /*}}}*/ + } +-//------------------------------------------------------------------------------------ ++ + using namespace com_example_issm; +- +-extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved) ++extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved) /*{{{*/ + { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { +@@ -71,4 +97,4 @@ + else return -1; + } + } +-/////////////////////////////////////////////////////////////////////////////////////////// ++/*}}}*/ +Index: ../trunk-jpl/src/android/ISSM/project.properties +=================================================================== +--- ../trunk-jpl/src/android/ISSM/project.properties (revision 14080) ++++ ../trunk-jpl/src/android/ISSM/project.properties (revision 14081) +@@ -11,4 +11,4 @@ + #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + + # Project target. +-target=Google Inc.:Google APIs:16 ++target=android-14 +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14080) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14081) +@@ -54,13 +54,15 @@ + //------------------------------------------------------------------------------------------------ + public void createModel() + { ++ String solution_type="DiagnosticSolution"; + String file = ""; + if( mapName.equals("greenland")) + { +- file = "test102.petsc"; ++ file = "test102"; + } +- else file = "test102.petsc"; +- size = issmNative.createISSMModel(issmFolder + file); ++ else file = "test102"; ++ ++ size = issmNative.createISSMModel(solution_type,issmFolder + file,file); + } + //------------------------------------------------------------------------------------------------ + public void fillBuffer() +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java (revision 14080) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java (revision 14081) +@@ -5,7 +5,7 @@ + { + public native long fac(long n); + public native void processBuffer(int alpha, DoubleBuffer buff); +- public native int createISSMModel(String file); ++ public native int createISSMModel(String solution_type, String absfile, String relfile); + static + { + System.loadLibrary("IssmJni"); +Index: ../trunk-jpl/src/android/ISSM +=================================================================== +--- ../trunk-jpl/src/android/ISSM (revision 14080) ++++ ../trunk-jpl/src/android/ISSM (revision 14081) + +Property changes on: ../trunk-jpl/src/android/ISSM +___________________________________________________________________ +Modified: svn:ignore +## -1,6 +1,7 ## +-gen ++gen* + .settings + libs + obj + Makefile + Makefile.in ++bin Index: /issm/oecreview/Archive/14064-14311/ISSM-14081-14082.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14081-14082.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14081-14082.diff (revision 14312) @@ -0,0 +1,157 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk (revision 14081) ++++ ../trunk-jpl/src/android/ISSM/jni/issmlib/Android.mk (revision 14082) +@@ -1,6 +1,7 @@ + LOCAL_PATH:= $(call my-dir) + include $(CLEAR_VARS) + LOCAL_MODULE := libISSMCore ++LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog + LOCAL_SRC_FILES := libISSMCore.a + LOCAL_EXPORT_C_INCLUDES := $(ISSM_DIR) + include $(PREBUILT_STATIC_LIBRARY) +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14081) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14082) +@@ -1,5 +1,6 @@ + #include + #include "../../../c/android/fac.h" ++#include + #include "../../../c/issm.h" + #include + #include +@@ -44,10 +45,10 @@ + env->ReleaseStringUTFChars(jsolution_type, solution_type); //must realease the char* + env->ReleaseStringUTFChars(jabsfile, absfile); //must realease the char* + env->ReleaseStringUTFChars(jrelfile, relfile); //must realease the char* +- ++ + /*figure out size of solution: */ + //jint size = (jint) fm->bufferSize(); +- jint size =7; ++ jint size =8; + + return size; + +Index: ../trunk-jpl/src/android/ISSM/jni/Android.mk +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Android.mk (revision 14081) ++++ ../trunk-jpl/src/android/ISSM/jni/Android.mk (revision 14082) +@@ -11,7 +11,8 @@ + LOCAL_PATH := $(my_LOCAL_PATH) + LOCAL_ALLOW_UNDEFINED_SYMBOLS := true + LOCAL_CFLAGS := -Wno-psabi -DHAVE_CONFIG_H +-LOCAL_LDLIBS := -llog -ldl -lm ++LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog -ldl -lm ++#LOCAL_LDLIBS := -llog -ldl -lm + LOCAL_MODULE := IssmJni + LOCAL_SRC_FILES := Main.cpp + LOCAL_STATIC_LIBRARIES := libISSMCore libgsl libgslcblas +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14081) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14082) +@@ -58,11 +58,11 @@ + String file = ""; + if( mapName.equals("greenland")) + { +- file = "test102"; ++ file = "greenland"; + } +- else file = "test102"; ++ else file = "antarctica"; + +- size = issmNative.createISSMModel(solution_type,issmFolder + file,file); ++ size = issmNative.createISSMModel(solution_type,issmFolder,file); + } + //------------------------------------------------------------------------------------------------ + public void fillBuffer() +Index: ../trunk-jpl/src/android/ISSM_Visual/bin/AndroidManifest.xml +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/bin/AndroidManifest.xml (revision 14081) ++++ ../trunk-jpl/src/android/ISSM_Visual/bin/AndroidManifest.xml (revision 14082) +@@ -1,5 +1,5 @@ + + +Index: ../trunk-jpl/src/android/ISSM_Visual/bin/resources.ap_ +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM_Visual/bin/classes.dex +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/c/io/PrintfFunction.cpp +=================================================================== +--- ../trunk-jpl/src/c/io/PrintfFunction.cpp (revision 14081) ++++ ../trunk-jpl/src/c/io/PrintfFunction.cpp (revision 14082) +@@ -8,6 +8,10 @@ + #include "../shared/shared.h" + #include "../include/include.h" + ++#ifdef _HAVE_ANDROID_NDK_ ++#include ++#endif ++ + int PrintfFunction(const char* format,...){ + /*http://linux.die.net/man/3/vsnprintf*/ + +@@ -57,7 +61,11 @@ + my_rank=IssmComm::GetRank(); + + if(my_rank==0){ ++ #ifdef _HAVE_ANDROID_JNI_ ++ __android_log_print(ANDROID_LOG_INFO, "Native",message.c_str()); ++ #else + printf("%s\n",message.c_str()); ++ #endif + } + return 1; + } +Index: ../trunk-jpl/src/c/Makefile.am +=================================================================== +--- ../trunk-jpl/src/c/Makefile.am (revision 14081) ++++ ../trunk-jpl/src/c/Makefile.am (revision 14082) +@@ -1,4 +1,4 @@ +-AM_CPPFLAGS = @DAKOTAINCL@ @SHAPELIBINCL@ @PETSCINCL@ @SLEPCINCL@ @MPIINCL@ @METISINCL@ @CHACOINCL@ @SCOTCHINCL@ @PLAPACKINCL@ @BLASLAPACKINCL@ @MKLINCL@ @MUMPSINCL@ @TRIANGLEINCL@ @SPAIINCL@ @HYPREINCL@ @PROMETHEUSINCL@ @SUPERLUINCL@ @SPOOLESINCL@ @PASTIXINCL@ @MLINCL@ @TAOINCL@ @ADIC2INCL@ @ADOLCINCL@ @GSLINCL@ @BOOSTINCL@ ++AM_CPPFLAGS = @DAKOTAINCL@ @SHAPELIBINCL@ @PETSCINCL@ @SLEPCINCL@ @MPIINCL@ @METISINCL@ @CHACOINCL@ @SCOTCHINCL@ @PLAPACKINCL@ @BLASLAPACKINCL@ @MKLINCL@ @MUMPSINCL@ @TRIANGLEINCL@ @SPAIINCL@ @HYPREINCL@ @PROMETHEUSINCL@ @SUPERLUINCL@ @SPOOLESINCL@ @PASTIXINCL@ @MLINCL@ @TAOINCL@ @ADIC2INCL@ @ADOLCINCL@ @GSLINCL@ @BOOSTINCL@ @ANDROID_NDKINCL@ + + EXEEXT=$(ISSMEXT) + +Index: ../trunk-jpl/src/c/classes/FemModel.cpp +=================================================================== +--- ../trunk-jpl/src/c/classes/FemModel.cpp (revision 14081) ++++ ../trunk-jpl/src/c/classes/FemModel.cpp (revision 14082) +@@ -19,11 +19,6 @@ + #include "../modules/modules.h" + + /*Object constructors and destructor*/ +-/*FUNCTION FemModel::FemModel(char* filename) {{{*/ +-FemModel::FemModel(char* filename){ +- +-} +-/*}}}*/ + /*FUNCTION FemModel::FemModel(int argc,char** argv){{{*/ + FemModel::FemModel(int argc,char** argv,COMM incomm){ + +Index: ../trunk-jpl/src/c/classes/FemModel.h +=================================================================== +--- ../trunk-jpl/src/c/classes/FemModel.h (revision 14081) ++++ ../trunk-jpl/src/c/classes/FemModel.h (revision 14082) +@@ -46,7 +46,6 @@ + COMM comm; //communicator for this particular model + + /*constructors, destructors: */ +- FemModel(char* filename); + FemModel(int argc,char** argv,COMM comm_init); + FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* petscfilename, char* lockfilename, const int solution_type,const int* analyses,const int nummodels); + ~FemModel(); Index: /issm/oecreview/Archive/14064-14311/ISSM-14082-14083.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14082-14083.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14082-14083.diff (revision 14312) @@ -0,0 +1,76 @@ +Index: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin (revision 14082) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin (revision 14083) + +Property changes on: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin +___________________________________________________________________ +Added: svn:mime-type +## -0,0 +1 ## ++application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc (revision 0) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc (revision 14083) +@@ -0,0 +1,19 @@ ++%Petsc options file: test102.petsc written from Matlab solver array ++ +++NoneAnalysis ++-mat_type aij ++-ksp_type gmres ++-pc_type asm ++-sub_pc_type ilu ++-pc_asm_overlap 5 ++-ksp_max_it 100 ++-ksp_rtol 1e-15 ++ +++DiagnosticVertAnalysis ++-mat_type aij ++-ksp_type gmres ++-pc_type asm ++-sub_pc_type ilu ++-pc_asm_overlap 5 ++-ksp_max_it 100 ++-ksp_rtol 1e-15 +Index: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin (revision 14082) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin (revision 14083) + +Property changes on: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin +___________________________________________________________________ +Added: svn:mime-type +## -0,0 +1 ## ++application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc (revision 0) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc (revision 14083) +@@ -0,0 +1,19 @@ ++%Petsc options file: test102.petsc written from Matlab solver array ++ +++NoneAnalysis ++-mat_type aij ++-ksp_type gmres ++-pc_type asm ++-sub_pc_type ilu ++-pc_asm_overlap 5 ++-ksp_max_it 100 ++-ksp_rtol 1e-15 ++ +++DiagnosticVertAnalysis ++-mat_type aij ++-ksp_type gmres ++-pc_type asm ++-sub_pc_type ilu ++-pc_asm_overlap 5 ++-ksp_max_it 100 ++-ksp_rtol 1e-15 Index: /issm/oecreview/Archive/14064-14311/ISSM-14083-14084.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14083-14084.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14083-14084.diff (revision 14312) @@ -0,0 +1,14 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14083) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14084) +@@ -47,8 +47,7 @@ + env->ReleaseStringUTFChars(jrelfile, relfile); //must realease the char* + + /*figure out size of solution: */ +- //jint size = (jint) fm->bufferSize(); +- jint size =8; ++ jint size = (jint) fm->elements->NumberOfElements(); + + return size; + Index: /issm/oecreview/Archive/14064-14311/ISSM-14084-14085.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14084-14085.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14084-14085.diff (revision 14312) @@ -0,0 +1,13 @@ +Index: ../trunk-jpl/src/android/ISSM/bin +=================================================================== +--- ../trunk-jpl/src/android/ISSM/bin (revision 14084) ++++ ../trunk-jpl/src/android/ISSM/bin (revision 14085) + +Property changes on: ../trunk-jpl/src/android/ISSM/bin +___________________________________________________________________ +Modified: svn:ignore +## -1,3 +1,4 ## ++com.* + *ISSM.apk + resources.ap_ + res Index: /issm/oecreview/Archive/14064-14311/ISSM-14085-14086.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14085-14086.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14085-14086.diff (revision 14312) @@ -0,0 +1,56 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14085) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14086) +@@ -53,13 +53,14 @@ + + } + /*}}}*/ +- void solve(JNIEnv *env, jclass clazz , jint alpha, jobject buf) /*{{{*/ ++ void Solve(JNIEnv *env, jclass clazz , jdouble alpha, jobject buf) /*{{{*/ + { + /*fill out the first two slots, extract the same way in java using get(int position)*/ + jdouble *dBuf = (jdouble *)env->GetDirectBufferAddress(buf); + + //pass bBuff to fem model to allocate data +- // fm -> solve(dBuf, alpha); ++ // fm -> Solve(dBuf, alpha); ++ fm -> Solve(); + + }/*}}}*/ + jlong factorial(JNIEnv *env, jclass clazz, jlong n) /*{{{*/ +@@ -73,7 +74,7 @@ + { + {"fac" , "(J)J" , (void *) factorial}, + {"createISSMModel" ,"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I" , (void *) initialize}, +- {"processBuffer", "(ILjava/nio/DoubleBuffer;)V", (void *) solve} ++ {"solveISSMModel", "(DLjava/nio/DoubleBuffer;)V", (void *) Solve} + }; + /*}}}*/ + } +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14085) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14086) +@@ -67,7 +67,7 @@ + //------------------------------------------------------------------------------------------------ + public void fillBuffer() + { +- issmNative.processBuffer(5,buff); ++ issmNative.solveISSMModel(5,buff); + } + //------------------------------------------------------------------------------------------------ + public void onClick(View view) +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java (revision 14085) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/IssmJni.java (revision 14086) +@@ -4,7 +4,7 @@ + class IssmJni + { + public native long fac(long n); +- public native void processBuffer(int alpha, DoubleBuffer buff); ++ public native void solveISSMModel(double alpha, DoubleBuffer buff); + public native int createISSMModel(String solution_type, String absfile, String relfile); + static + { Index: /issm/oecreview/Archive/14064-14311/ISSM-14086-14087.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14086-14087.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14086-14087.diff (revision 14312) @@ -0,0 +1,22 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14086) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14087) +@@ -11,7 +11,7 @@ + fac* f; + FemModel *fm; + /*}}}*/ +- jint initialize(JNIEnv *env, jclass clazz, jstring jsolution_type, jstring jabsfile, jstring jrelfile) /*{{{*/ ++ jint Initialize(JNIEnv *env, jclass clazz, jstring jsolution_type, jstring jabsfile, jstring jrelfile) /*{{{*/ + { + + /*arguments to constructor: */ +@@ -73,7 +73,7 @@ + static JNINativeMethod method_table[] = /*{{{*/ + { + {"fac" , "(J)J" , (void *) factorial}, +- {"createISSMModel" ,"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I" , (void *) initialize}, ++ {"createISSMModel" ,"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I" , (void *) Initialize}, + {"solveISSMModel", "(DLjava/nio/DoubleBuffer;)V", (void *) Solve} + }; + /*}}}*/ Index: /issm/oecreview/Archive/14064-14311/ISSM-14087-14088.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14087-14088.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14087-14088.diff (revision 14312) @@ -0,0 +1,53 @@ +Index: ../trunk-jpl/m4/issm_options.m4 +=================================================================== +--- ../trunk-jpl/m4/issm_options.m4 (revision 14087) ++++ ../trunk-jpl/m4/issm_options.m4 (revision 14088) +@@ -1325,8 +1325,8 @@ + + dnl defaults + HAVE_ANDROID=jni +- + AC_DEFINE([_HAVE_ANDROID_],[1],[with android capability]) ++ AC_DEFINE([_HAVE_ANDROID_JNI_],[1],[with android jni]) + elif test "x$ANDROID" = "xexe"; then + dnl defaults + HAVE_ANDROID=exe +@@ -1342,6 +1342,24 @@ + AM_CONDITIONAL([ANDROIDEXE], [test x$HAVE_ANDROID = xexe]) + AC_MSG_RESULT($HAVE_ANDROID) + dnl }}} ++ dnl with-android-ndk{{{ ++ AC_ARG_WITH([android-ndk], ++ AS_HELP_STRING([--with-android-ndk=DIR], [android-ndk root directory.]), ++ [ANDROID_NDK_ROOT=$withval],[ANDROID_NDK_ROOT=""]) ++ AC_MSG_CHECKING(with android ndk) ++ ++ if test -d "$ANDROID_NDK_ROOT"; then ++ dnl defaults ++ HAVE_ANDROID_NDK=yes ++ ANDROID_NDKINCL="-I$ANDROID_NDK_ROOT/arm-linux-android-install/sysroot/usr/include" ++ ++ AC_DEFINE([_HAVE_ANDROID_NDK_],[1],[with android ndk in ISSM src]) ++ AC_SUBST([ANDROID_NDKINCL]) ++ else ++ HAVE_ANDROID_NDK=no ++ fi ++ AC_MSG_RESULT($HAVE_ANDROID_NDK) ++ dnl }}} + dnl with-3d{{{ + AC_ARG_WITH([3d], + AS_HELP_STRING([--with-3d = YES], [compile with 3d capabilities (default is yes)]), +Index: ../trunk-jpl/configs/config-arm-linux.sh +=================================================================== +--- ../trunk-jpl/configs/config-arm-linux.sh (revision 14087) ++++ ../trunk-jpl/configs/config-arm-linux.sh (revision 14088) +@@ -5,7 +5,8 @@ + --build="i386-apple-darwin10.8.0" \ + --host="arm-linux-androideabi" \ + --enable-shared \ +- --with-android=jni\ ++ --with-android=jni \ ++ --with-android-ndk=$ISSM_DIR/externalpackages/android/android-ndk/install \ + --without-fortran \ + --without-wrappers \ + --without-kriging \ Index: /issm/oecreview/Archive/14064-14311/ISSM-14088-14089.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14088-14089.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14088-14089.diff (revision 14312) @@ -0,0 +1,194 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/issmlib/libISSMCore.a +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14088) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14089) +@@ -4,12 +4,14 @@ + #include "../../../c/issm.h" + #include + #include ++#include + + namespace com_example_issm + { + /*Global variables{{{*/ + fac* f; + FemModel *fm; ++ double* xyz; /*keep vertices information here*/ + /*}}}*/ + jint Initialize(JNIEnv *env, jclass clazz, jstring jsolution_type, jstring jabsfile, jstring jrelfile) /*{{{*/ + { +@@ -23,6 +25,9 @@ + char *absfile = NULL; + char *relfile = NULL; + ++ /*log:*/ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Initializing FemModel"); ++ + /*retrieve from java machine: */ + solution_type = (char*)env->GetStringUTFChars(jsolution_type,0); + absfile = (char*)env->GetStringUTFChars(jabsfile,0); +@@ -47,21 +52,103 @@ + env->ReleaseStringUTFChars(jrelfile, relfile); //must realease the char* + + /*figure out size of solution: */ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Number of elements"); + jint size = (jint) fm->elements->NumberOfElements(); ++ ++ /*retrieve vertices x,y and z coordinates: */ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Retrieving vertices"); ++ xyz=fm->vertices->ToXYZ(); + ++ /*log: */ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Done Initializing FemModel"); ++ + return size; + + } + /*}}}*/ +- void Solve(JNIEnv *env, jclass clazz , jdouble alpha, jobject buf) /*{{{*/ +- { ++ void Solve(JNIEnv *env, jclass clazz , jdouble alpha, jobject buf){ /*{{{*/ ++ ++ int i,count; ++ double x1,y1,z1,vel1; ++ double x2,y2,z2,vel2; ++ double x3,y3,z3,vel3; ++ int v1,v2,v3,eid; ++ Patch* patch=NULL; ++ ++ /*log:*/ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Solving "); ++ + /*fill out the first two slots, extract the same way in java using get(int position)*/ + jdouble *dBuf = (jdouble *)env->GetDirectBufferAddress(buf); + +- //pass bBuff to fem model to allocate data +- // fm -> Solve(dBuf, alpha); ++ /*pass bBuff to fem model to allocate data. In the future: fm -> Solve(dBuf, alpha)*/ + fm -> Solve(); + ++ /*retrieve results: */ ++ __android_log_print(ANDROID_LOG_INFO, "Native","Retrieving results "); ++ patch=fm->elements->ResultsToPatch(); ++ ++ /*sort out the velocities: */ ++ for(i=0;inumrows;i++){ ++ if ((patch->values[i*patch->numcols+0])==VelEnum){ ++ ++ /*Each row of the Patch object is made of the following information: ++ - the result enum_type, ++ - the step and time, ++ - the id of the element, ++ - the interpolation type, ++ - the vertices ids, ++ - and the values at the nodes (could be different from the vertices) ++ */ ++ eid=(int)patch->values[i*patch->numcols+3]-1; ++ v1=(int)patch->values[i*patch->numcols+5]; ++ x1=xyz[3*(v1-1)+0]; y1=xyz[3*(v1-1)+1]; z1=xyz[3*(v1-1)+2]; ++ ++ v2=(int)patch->values[i*patch->numcols+6]; ++ x2=xyz[3*(v2-1)+0]; y2=xyz[3*(v2-1)+1]; z2=xyz[3*(v2-1)+2]; ++ ++ v3=(int)patch->values[i*patch->numcols+7]; ++ x3=xyz[3*(v3-1)+0]; y3=xyz[3*(v3-1)+1]; z3=xyz[3*(v3-1)+2]; ++ ++ vel1=patch->values[i*patch->numcols+8]; ++ vel2=patch->values[i*patch->numcols+9]; ++ vel3=patch->values[i*patch->numcols+10]; ++ ++ /*plug into dBuf: */ ++ /*vertex 1: */ ++ dBuf[12*eid+0]=x1; ++ dBuf[12*eid+1]=y1; ++ dBuf[12*eid+2]=z1; ++ ++ /*vertex 2: */ ++ dBuf[12*eid+3]=x2; ++ dBuf[12*eid+4]=y2; ++ dBuf[12*eid+5]=z2; ++ ++ /*vertex 3: */ ++ dBuf[12*eid+6]=x3; ++ dBuf[12*eid+7]=y3; ++ dBuf[12*eid+8]=z3; ++ ++ /*values at 3 vertices: */ ++ dBuf[12*eid+9]=vel1; ++ dBuf[12*eid+10]=vel2; ++ dBuf[12*eid+11]=vel3; ++ ++ } ++ } ++ ++ /*for(i=0;i<148;i++){ ++ __android_log_print(ANDROID_LOG_INFO, "Native","%g %g %g | %g %g %g | %g %g %g | %g %g %g\n", ++ dBuf[12*i+0],dBuf[12*i+1],dBuf[12*i+2], ++ dBuf[12*i+3],dBuf[12*i+4],dBuf[12*i+5], ++ dBuf[12*i+6],dBuf[12*i+7],dBuf[12*i+8], ++ dBuf[12*i+9],dBuf[12*i+10],dBuf[12*i+11]); ++ }*/ ++ ++ /*delete temporary data:*/ ++ delete patch; ++ + }/*}}}*/ + jlong factorial(JNIEnv *env, jclass clazz, jlong n) /*{{{*/ + { +Index: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.bin +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc (revision 14088) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/antarctica.petsc (revision 14089) +@@ -1,4 +1,4 @@ +-%Petsc options file: test102.petsc written from Matlab solver array ++%Petsc options file: android.petsc written from Matlab solver array + + +NoneAnalysis + -mat_type aij +Index: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.bin +=================================================================== +Cannot display: file marked as a binary type. +svn:mime-type = application/octet-stream +Index: ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc +=================================================================== +--- ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc (revision 14088) ++++ ../trunk-jpl/src/android/ISSM/assets/Map/greenland.petsc (revision 14089) +@@ -1,4 +1,4 @@ +-%Petsc options file: test102.petsc written from Matlab solver array ++%Petsc options file: android.petsc written from Matlab solver array + + +NoneAnalysis + -mat_type aij +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14088) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14089) +@@ -48,8 +48,8 @@ + //load up the ISSM library and create double buffer in java + //which later on will be pass for native allocation. + issmNative = new IssmJni(); +- buff = ByteBuffer.allocateDirect(15*8).order(ByteOrder.nativeOrder()).asDoubleBuffer(); + this.createModel(); ++ buff = ByteBuffer.allocateDirect(size*12*8).order(ByteOrder.nativeOrder()).asDoubleBuffer(); + } + //------------------------------------------------------------------------------------------------ + public void createModel() +@@ -68,6 +68,10 @@ + public void fillBuffer() + { + issmNative.solveISSMModel(5,buff); ++ ++ //for(int i=0;i< size*12;i++) ++ //System.out.println(buff.get(i)); ++ + } + //------------------------------------------------------------------------------------------------ + public void onClick(View view) Index: /issm/oecreview/Archive/14064-14311/ISSM-14089-14090.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14089-14090.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14089-14090.diff (revision 14312) @@ -0,0 +1,107 @@ +Index: ../trunk-jpl/src/c/Container/Vertices.cpp +=================================================================== +--- ../trunk-jpl/src/c/Container/Vertices.cpp (revision 14089) ++++ ../trunk-jpl/src/c/Container/Vertices.cpp (revision 14090) +@@ -198,3 +198,46 @@ + } + } + /*}}}*/ ++/*FUNCTION Vertices::ToXYZ{{{*/ ++double* Vertices::ToXYZ(void){ ++ ++ /*intermediary: */ ++ int i; ++ int my_rank; ++ int num_vertices; ++ ++ /*output: */ ++ Matrix* xyz = NULL; ++ double* xyz_serial=NULL; ++ ++ /*recover my_rank:*/ ++ my_rank=IssmComm::GetRank(); ++ ++ /*First, figure out number of vertices: */ ++ num_vertices=this->NumberOfVertices(); ++ ++ /*Now, allocate matrix to hold all the vertices x,y and z values: */ ++ xyz= new Matrix(num_vertices,3); ++ ++ /*Go through vertices, and for each vertex, object, report it cpu: */ ++ for(i=0;iSize();i++){ ++ ++ /*let vertex fill matrix: */ ++ Vertex* vertex=dynamic_cast(this->GetObjectByOffset(i)); ++ vertex->ToXYZ(xyz); ++ } ++ ++ /*Assemble:*/ ++ xyz->Assemble(); ++ ++ /*gather on cpu 0: */ ++ xyz_serial=xyz->ToSerial(); ++ ++ /*free ressources: */ ++ delete xyz; ++ if(my_rank!=0)delete xyz_serial; ++ ++ /*return matrix: */ ++ return xyz_serial; ++} ++/*}}}*/ +Index: ../trunk-jpl/src/c/Container/Vertices.h +=================================================================== +--- ../trunk-jpl/src/c/Container/Vertices.h (revision 14089) ++++ ../trunk-jpl/src/c/Container/Vertices.h (revision 14090) +@@ -27,6 +27,7 @@ + void FlagClones(int numberofnodes); + int NumberOfVertices(void); + void Ranks(int* ranks); ++ double* ToXYZ(void); + }; + + #endif //ifndef _VERTICES_H_ +Index: ../trunk-jpl/src/c/classes/objects/Vertex.cpp +=================================================================== +--- ../trunk-jpl/src/c/classes/objects/Vertex.cpp (revision 14089) ++++ ../trunk-jpl/src/c/classes/objects/Vertex.cpp (revision 14090) +@@ -193,3 +193,20 @@ + + } + /*}}}*/ ++/*FUNCTION Vertex::ToXYZ {{{*/ ++void Vertex::ToXYZ(Matrix* matrix){ ++ ++ int i; ++ double xyz[3]; ++ int indices[3]; ++ ++ if (this->clone==true)return; ++ else{ ++ ++ xyz[0]=x; xyz[1]=y; xyz[2]=z; ++ indices[0]=0;indices[1]=1; indices[2]=2; ++ ++ matrix->SetValues(1,&sid,3,&indices[0],&xyz[0],INS_VAL); ++ } ++} ++/*}}}*/ +Index: ../trunk-jpl/src/c/classes/objects/Vertex.h +=================================================================== +--- ../trunk-jpl/src/c/classes/objects/Vertex.h (revision 14089) ++++ ../trunk-jpl/src/c/classes/objects/Vertex.h (revision 14090) +@@ -12,6 +12,7 @@ + #include "../../toolkits/toolkits.h" + #include "../../include/include.h" + template class Vector; ++template class Matrix; + class Parameters; + class IoModel; + /*}}}*/ +@@ -52,5 +53,6 @@ + void ShowTruePids(int* borderpids); + void UpdateClonePids(int* allborderpids); + void SetClone(int* minranks); ++ void ToXYZ(Matrix* matrix); + }; + #endif /* _VERTEX_H */ Index: /issm/oecreview/Archive/14064-14311/ISSM-14090-14091.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14090-14091.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14090-14091.diff (revision 14312) @@ -0,0 +1,37 @@ +Index: ../trunk-jpl/test/NightlyRun/android.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/android.m (revision 0) ++++ ../trunk-jpl/test/NightlyRun/android.m (revision 14091) +@@ -0,0 +1,32 @@ ++md=triangle(model(),'../Exp/Square.exp',100000.); ++md=setmask(md,'all',''); ++md=parameterize(md,'../Par/SquareShelfConstrained.par'); ++md=setflowequation(md,'macayeal','all'); ++md.cluster=generic('name',oshostname(),'np',3); ++md.verbose=verbose('mprocessor',true,'module',true,'solution',true,'solver',true,'convergence',true,'control',true,'qmu',true,'autodiff',true); ++md.diagnostic.requested_outputs=StressTensorEnum(); ++md=solve(md,DiagnosticSolutionEnum()); ++ ++ ++index=md.mesh.elements; ++nel=length(index); ++x=md.mesh.x; ++y=md.mesh.y; ++z=md.mesh.z; ++vel=md.results.DiagnosticSolution.Vel; ++ ++patch=zeros(nel,12); ++for i=1:nel, ++ patch(i,1)=x(index(i,1)); ++ patch(i,2)=y(index(i,1)); ++ patch(i,3)=z(index(i,1)); ++ patch(i,4)=x(index(i,2)); ++ patch(i,5)=y(index(i,2)); ++ patch(i,6)=z(index(i,2)); ++ patch(i,7)=x(index(i,3)); ++ patch(i,8)=y(index(i,3)); ++ patch(i,9)=z(index(i,3)); ++ patch(i,10)=vel(index(i,1)); ++ patch(i,11)=vel(index(i,2)); ++ patch(i,12)=vel(index(i,3)); ++end Index: /issm/oecreview/Archive/14064-14311/ISSM-14091-14092.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14091-14092.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14091-14092.diff (revision 14312) @@ -0,0 +1,111 @@ +Index: ../trunk-jpl/src/m/mesh/squaremesh.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/squaremesh.py (revision 0) ++++ ../trunk-jpl/src/m/mesh/squaremesh.py (revision 14092) +@@ -0,0 +1,83 @@ ++import numpy ++from NodeConnectivity import * ++from ElementConnectivity import * ++ ++def squaremesh(md,Lx,Ly,nx,ny): ++ """ ++ SQUAREMESH - create a structured square mesh ++ ++ This script will generate a structured square mesh ++ Lx and Ly are the dimension of the domain (in meters) ++ nx anx ny are the number of nodes in the x and y direction ++ The coordinates x and y returned are in meters. ++ ++ Usage: ++ [md]=squaremesh(md,Lx,Ly,nx,ny) ++ """ ++ ++ #get number of elements and number of nodes ++ nel=(nx-1)*(ny-1)*2 ++ nods=nx*ny ++ ++ #initialization ++ index=numpy.zeros((nel,3),int) ++ x=numpy.zeros((nx*ny,1)) ++ y=numpy.zeros((nx*ny,1)) ++ ++ #create coordinates ++ for n in xrange(0,nx): ++ for m in xrange(0,ny): ++ x[n*ny+m]=float(n) ++ y[n*ny+m]=float(m) ++ ++ #create index ++ for n in xrange(0,nx-1): ++ for m in xrange(0,ny-1): ++ A=n*ny+(m+1) ++ B=A+1 ++ C=(n+1)*ny+(m+1) ++ D=C+1 ++ index[n*(ny-1)*2+2*m,:]=[A,C,B] ++ index[n*(ny-1)*2+2*(m+1)-1,:]=[B,C,D] ++ ++ #Scale x and y ++ x=x/numpy.max(x)*Lx ++ y=y/numpy.max(y)*Ly ++ ++ #create segments ++ segments=numpy.zeros((2*(nx-1)+2*(ny-1),3),int) ++ #left edge: ++ segments[0:ny-1,:]=numpy.hstack((numpy.arange(2,ny+1).reshape(-1,1),numpy.arange(1,ny).reshape(-1,1),(2*numpy.arange(1,ny)-1).reshape(-1,1))) ++ #right edge: ++ segments[ny-1:2*(ny-1),:]=numpy.hstack((numpy.arange(ny*(nx-1)+1,nx*ny).reshape(-1,1),numpy.arange(ny*(nx-1)+2,nx*ny+1).reshape(-1,1),2*numpy.arange((ny-1)*(nx-2)+1,(nx-1)*(ny-1)+1).reshape(-1,1))) ++ #front edge: ++ segments[2*(ny-1):2*(ny-1)+(nx-1),:]=numpy.hstack((numpy.arange(2*ny,ny*nx+1,ny).reshape(-1,1),numpy.arange(ny,ny*(nx-1)+1,ny).reshape(-1,1),numpy.arange(2*(ny-1),2*(nx-1)*(ny-1)+1,2*(ny-1)).reshape(-1,1))) ++ #back edge ++ segments[2*(ny-1)+(nx-1):2*(nx-1)+2*(ny-1),:]=numpy.hstack((numpy.arange(1,(nx-2)*ny+2,ny).reshape(-1,1),numpy.arange(ny+1,ny*(nx-1)+2,ny).reshape(-1,1),numpy.arange(1,2*(nx-2)*(ny-1)+2,2*(ny-1)).reshape(-1,1))) ++ ++ #plug coordinates and nodes ++ md.mesh.x=x ++ md.mesh.y=y ++ md.mesh.z=numpy.zeros((nods,1)) ++ md.mesh.numberofvertices=nods ++ md.mesh.vertexonboundary=numpy.zeros((nods,1),bool) ++ md.mesh.vertexonboundary[segments[:,0:2]-1]=True ++ md.mesh.vertexonbed=numpy.ones((nods,1),bool) ++ md.mesh.vertexonsurface=numpy.ones((nods,1),bool) ++ ++ #plug elements ++ md.mesh.elements=index ++ md.mesh.segments=segments ++ md.mesh.numberofelements=nel ++ md.mesh.elementonbed=numpy.ones((nel,1),bool) ++ md.mesh.elementonsurface=numpy.ones((nel,1),bool) ++ ++ #Now, build the connectivity tables for this mesh. ++ [md.mesh.vertexconnectivity]=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices) ++ [md.mesh.elementconnectivity]=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity) ++ ++ #plug other field ++ md.mesh.dimension=2 ++ ++ return md ++ +Index: ../trunk-jpl/src/m/mesh/squaremesh.m +=================================================================== +--- ../trunk-jpl/src/m/mesh/squaremesh.m (revision 14091) ++++ ../trunk-jpl/src/m/mesh/squaremesh.m (revision 14092) +@@ -14,7 +14,6 @@ + nods=nx*ny; + + %initialization +-segments=zeros(0,3); + index=zeros(nel,3); + x=zeros(nx*ny,1); + y=zeros(nx*ny,1); +@@ -22,8 +21,8 @@ + %create coordinates + for n=1:nx, + for m=1:ny, +- x((n-1)*ny+m)=(n-1); +- y((n-1)*ny+m)=(m-1); ++ x((n-1)*ny+m)=(n-1.); ++ y((n-1)*ny+m)=(m-1.); + end + end + Index: /issm/oecreview/Archive/14064-14311/ISSM-14092-14093.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14092-14093.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14092-14093.diff (revision 14312) @@ -0,0 +1,269 @@ +Index: ../trunk-jpl/src/wrappers/python/io/pythonio.h +=================================================================== +--- ../trunk-jpl/src/wrappers/python/io/pythonio.h (revision 14092) ++++ ../trunk-jpl/src/wrappers/python/io/pythonio.h (revision 14093) +@@ -33,7 +33,7 @@ + void FetchData(int** pmatrix,int* pM,int *pN,PyObject* py_matrix); + void FetchData(char** pstring,PyObject* py_unicode); + void FetchData(double* pscalar,PyObject* py_float); +-void FetchData(int* pinteger,PyObject* py_long); ++void FetchData(int* pscalar,PyObject* py_long); + void FetchData(bool* pbool,PyObject* py_boolean); + void FetchData(BamgGeom** bamggeom,PyObject* py_dict); + void FetchData(BamgMesh** bamgmesh,PyObject* py_dict); +Index: ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp +=================================================================== +--- ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp (revision 14092) ++++ ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp (revision 14093) +@@ -19,40 +19,58 @@ + /*FUNCTION FetchData(double* pscalar,PyObject* py_float){{{*/ + void FetchData(double* pscalar,PyObject* py_float){ + +- double scalar; ++ double dscalar; + + /*return internal value: */ +- scalar=PyFloat_AsDouble(py_float); ++ if (PyFloat_Check((PyArrayObject*)py_float)) ++ dscalar=PyFloat_AsDouble(py_float); ++ else if (PyInt_Check((PyArrayObject*)py_float)) ++ dscalar=(double)PyInt_AsLong(py_float); ++ else if (PyLong_Check((PyArrayObject*)py_float)) ++ dscalar=PyLong_AsDouble(py_float); ++ else if (PyBool_Check((PyArrayObject*)py_float)) ++ dscalar=(double)PyLong_AsLong(py_float); ++ else ++ _error_("unrecognized float type in input!"); + + /*output: */ +- *pscalar=scalar; ++ *pscalar=dscalar; + } + /*}}}*/ +-/*FUNCTION FetchData(int* pinteger,PyObject* py_long){{{*/ +-void FetchData(int* pinteger, PyObject* py_long){ ++/*FUNCTION FetchData(int* pscalar,PyObject* py_long){{{*/ ++void FetchData(int* pscalar, PyObject* py_long){ + +- int integer; ++ int iscalar; + + /*return internal value: */ +- integer=(int)PyLong_AsLong(py_long); ++ if (PyInt_Check((PyArrayObject*)py_long)) ++ iscalar=(int)PyInt_AsLong(py_long); ++ else if (PyLong_Check((PyArrayObject*)py_long)) ++ iscalar=(int)PyLong_AsLong(py_long); ++ else if (PyFloat_Check((PyArrayObject*)py_long)) ++ iscalar=(int)PyFloat_AsDouble(py_long); ++ else if (PyBool_Check((PyArrayObject*)py_long)) ++ iscalar=(int)PyLong_AsLong(py_long); ++ else ++ _error_("unrecognized long type in input!"); + + /*output: */ +- *pinteger=integer; ++ *pscalar=iscalar; + } + /*}}}*/ +-/*FUNCTION FetchData(bool* pboolean,PyObject* py_boolean){{{*/ +-void FetchData(bool* pboolean,PyObject* py_boolean){ ++/*FUNCTION FetchData(bool* pscalar,PyObject* py_boolean){{{*/ ++void FetchData(bool* pscalar,PyObject* py_boolean){ + +- bool boolean; ++ bool bscalar; + + /*check this is indeed a subtype of long type: */ + if(!PyBool_Check(py_boolean))_error_("expecting a boolean in input!"); + + /*extract boolean: */ +- boolean=(bool)PyLong_AsLong(py_boolean); ++ bscalar=(bool)PyLong_AsLong(py_boolean); + + /*simple copy: */ +- *pboolean=boolean; ++ *pscalar=bscalar; + + } + /*}}}*/ +@@ -71,45 +89,60 @@ + bool* bmatrix=NULL; + int i; + +- /*retrieve dimensions: */ +- ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); +- if(ndim!=2)_error_("expecting an MxN matrix in input!"); +- dims=PyArray_DIMS((PyArrayObject*)py_matrix); +- M=dims[0]; N=dims[1]; ++ if (PyArray_Check((PyArrayObject*)py_matrix)) { ++ /*retrieve dimensions: */ ++ ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); ++ if(ndim!=2)_error_("expecting an MxN matrix in input!"); ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=dims[1]; + +- if (M && N) { +- if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { +- /*retrieve internal value: */ +- dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix); ++ if (M && N) { ++ if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { ++ /*retrieve internal value: */ ++ dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix); + +- /*copy matrix: */ +- matrix=xNew(M*N); +- memcpy(matrix,dmatrix,(M*N)*sizeof(double)); +- } ++ /*copy matrix: */ ++ matrix=xNew(M*N); ++ memcpy(matrix,dmatrix,(M*N)*sizeof(double)); ++ } + +- else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_INT64) { +- /*retrieve internal value: */ +- lmatrix=(long*)PyArray_DATA((PyArrayObject*)py_matrix); ++ else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_INT64) { ++ /*retrieve internal value: */ ++ lmatrix=(long*)PyArray_DATA((PyArrayObject*)py_matrix); + +- /*transform into double matrix: */ +- matrix=xNew(M*N); +- for(i=0;i(M*N); ++ for(i=0;i(M*N); +- for(i=0;i(M*N); ++ for(i=0;i(M*N); ++ FetchData(&(matrix[0]),py_matrix); ++ } ++ + else +- matrix=NULL; ++ _error_("unrecognized array type in input!"); + + /*output: */ + if(pM)*pM=M; +@@ -132,45 +165,60 @@ + bool* bmatrix=NULL; + int i; + +- /*retrieve dimensions: */ +- ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); +- if(ndim!=2)_error_("expecting an MxN matrix in input!"); +- dims=PyArray_DIMS((PyArrayObject*)py_matrix); +- M=dims[0]; N=dims[1]; ++ if (PyArray_Check((PyArrayObject*)py_matrix)) { ++ /*retrieve dimensions: */ ++ ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); ++ if(ndim!=2)_error_("expecting an MxN matrix in input!"); ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=dims[1]; + +- if (M && N) { +- if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { +- /*retrieve internal value: */ +- dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix); ++ if (M && N) { ++ if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { ++ /*retrieve internal value: */ ++ dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix); + +- /*transform into integer matrix: */ +- matrix=xNew(M*N); +- for(i=0;i(M*N); ++ for(i=0;i(M*N); +- for(i=0;i(M*N); ++ for(i=0;i(M*N); +- for(i=0;i(M*N); ++ for(i=0;i(M*N); ++ FetchData(&(matrix[0]),py_matrix); ++ } ++ + else +- matrix=NULL; ++ _error_("unrecognized array type in input!"); + + /*output: */ + if(pM)*pM=M; Index: /issm/oecreview/Archive/14064-14311/ISSM-14093-14094.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14093-14094.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14093-14094.diff (revision 14312) @@ -0,0 +1,164 @@ +Index: ../trunk-jpl/src/m/contrib/bamg/YamsCall.m +=================================================================== +--- ../trunk-jpl/src/m/contrib/bamg/YamsCall.m (revision 14093) ++++ ../trunk-jpl/src/m/contrib/bamg/YamsCall.m (revision 14094) +@@ -15,7 +15,7 @@ + % md=YamsCall(md,md.inversion.vel_obs,1500,10^8,1.3,0.9); + + %2d geometric parameter (do not change) +-scale=2/9; ++scale=2./9.; + + %Compute Hessian + t1=clock; fprintf('%s',' computing Hessian...'); +@@ -59,7 +59,7 @@ + %we have the list of triangles that make up the rift. keep those triangles around during refinement. + triangles=[]; + for i=1:size(md.rifts.riftstruct,1), +- triangles=[triangles md.rifts(i).segments(:,3)']; ++ triangles=[triangles md.rifts(i).riftstruct.segments(:,3)']; + end + + fprintf(fid,'\n\n%s\n%i\n\n','RequiredTriangles',length(triangles)); +@@ -75,7 +75,7 @@ + if ispc() + %windows + system(['yams2-win -O 1 -v -0 -ecp -hgrad ' num2str(gradation) ' carre0 carre1']); +-elseif ismac ++elseif ismac() + %Macosx + system(['yams2-osx -O 1 -v -0 -ecp -hgrad ' num2str(gradation) ' carre0 carre1']); + else +Index: ../trunk-jpl/src/m/contrib/bamg/YamsCall.py +=================================================================== +--- ../trunk-jpl/src/m/contrib/bamg/YamsCall.py (revision 0) ++++ ../trunk-jpl/src/m/contrib/bamg/YamsCall.py (revision 14094) +@@ -0,0 +1,128 @@ ++import numpy ++import time ++import subprocess ++import os ++from ComputeHessian import * ++from ComputeMetric import * ++from MatlabFuncs import * ++ ++def YamsCall(md,field,hmin,hmax,gradation,epsilon): ++ """ ++ YAMSCALL - call yams ++ ++ build a metric using the Hessian of the given field ++ call Yams and the output mesh is plugged onto the model ++ -hmin = minimum edge length (m) ++ -hmax = maximum edge length (m) ++ -gradation = maximum edge length gradation between 2 elements ++ -epsilon = average error on each element (m/yr) ++ ++ Usage: ++ md=YamsCall(md,field,hmin,hmax,gradation,epsilon); ++ ++ Example: ++ md=YamsCall(md,md.inversion.vel_obs,1500,10^8,1.3,0.9); ++ """ ++ ++ #2d geometric parameter (do not change) ++ scale=2./9. ++ ++ #Compute Hessian ++ t1=time.time() ++ print "%s" % ' computing Hessian...' ++ hessian=ComputeHessian(md.mesh.elements,md.mesh.x,md.mesh.y,field,'node') ++ t2=time.time() ++ print "%s%d%s\n" % (' done (',t2-t1,' seconds)') ++ ++ #Compute metric ++ t1=time.time() ++ print "%s" % ' computing metric...' ++ if numpy.size(md.mask.vertexonwater)==md.mesh.numberofvertices: ++ pos=numpy.nonzero(md.mask.vertexonwater)[0] ++ else: ++ pos=numpy.empty(0,int) ++ metric=ComputeMetric(hessian,scale,epsilon,hmin,hmax,pos) ++ t2=time.time() ++ print "%s%d%s\n" % (' done (',t2-t1,' seconds)') ++ ++ #write files ++ t1=time.time() ++ print "%s" % ' writing initial mesh files...' ++ numpy.savetxt('carre0.met',metric) ++ ++ f=open('carre0.mesh','w') ++ ++ #initialiation ++ f.write("\n%s\n%i\n" % ('MeshVersionFormatted',1)) ++ ++ #dimension ++ f.write("\n%s\n%i\n" % ('Dimension',2)) ++ ++ #Vertices ++ f.write("\n%s\n%i\n\n" % ('Vertices',md.mesh.numberofvertices)) ++ for i in xrange(0,md.mesh.numberofvertices): ++ f.write("%8g %8g %i\n" % (md.mesh.x[i],md.mesh.y[i],0)) ++ ++ #Triangles ++ f.write("\n\n%s\n%i\n\n" % ('Triangles',md.mesh.numberofelements)) ++ for i in xrange(0,md.mesh.numberofelements): ++ f.write("%i %i %i %i\n" % (md.mesh.elements[i,0],md.mesh.elements[i,1],md.mesh.elements[i,2],0)) ++ numberofelements1=md.mesh.numberofelements ++ ++ #Deal with rifts ++ if numpy.any(not numpy.isnan(md.rifts.riftstruct)): ++ ++ #we have the list of triangles that make up the rift. keep those triangles around during refinement. ++ triangles=numpy.empty(0,int) ++ for riftstruct in md.rifts.riftstruct: ++ triangles=numpy.concatenate((triangles,riftstruct.segments[:,2])) ++ ++ f.write("\n\n%s\n%i\n\n" % ('RequiredTriangles',numpy.size(triangles))) ++ for triangle in triangles: ++ f.write("%i\n" % triangle) ++ ++ #close ++ f.close() ++ t2=time.time() ++ print "%s%d%s\n" % (' done (',t2-t1,' seconds)') ++ ++ #call yams ++ print "%s\n" % ' call Yams...' ++ if ispc(): ++ #windows ++ subprocess.call('yams2-win -O 1 -v -0 -ecp -hgrad %g carre0 carre1' % gradation,shell=True) ++ elif ismac(): ++ #Macosx ++ subprocess.call('yams2-osx -O 1 -v -0 -ecp -hgrad %g carre0 carre1' % gradation,shell=True) ++ else: ++ #Linux ++ subprocess.call('yams2-linux -O 1 -v -0 -ecp -hgrad %g carre0 carre1' % gradation,shell=True) ++ ++ #plug new mesh ++ t1=time.time() ++ print "\n%s" % ' reading final mesh files...' ++ Tria=numpy.loadtxt('carre1.tria',int) ++ Coor=numpy.loadtxt('carre1.coor',float) ++ md.mesh.x=Coor[:,0] ++ md.mesh.y=Coor[:,1] ++ md.mesh.z=numpy.zeros((numpy.size(Coor,axis=0),1)) ++ md.mesh.elements=Tria ++ md.mesh.numberofvertices=numpy.size(Coor,axis=0) ++ md.mesh.numberofelements=numpy.size(Tria,axis=0) ++ numberofelements2=md.mesh.numberofelements ++ t2=time.time() ++ print "%s%d%s\n\n" % (' done (',t2-t1,' seconds)') ++ ++ #display number of elements ++ print "\n%s %i" % (' inital number of elements:',numberofelements1) ++ print "\n%s %i\n\n" % (' new number of elements:',numberofelements2) ++ ++ #clean up: ++ os.remove('carre0.mesh') ++ os.remove('carre0.met') ++ os.remove('carre1.tria') ++ os.remove('carre1.coor') ++ os.remove('carre1.meshb') ++ ++ return md ++ Index: /issm/oecreview/Archive/14064-14311/ISSM-14094-14095.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14094-14095.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14094-14095.diff (revision 14312) @@ -0,0 +1,73 @@ +Index: ../trunk-jpl/src/m/mesh/squaremesh.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/squaremesh.py (revision 14094) ++++ ../trunk-jpl/src/m/mesh/squaremesh.py (revision 14095) +@@ -21,8 +21,8 @@ + + #initialization + index=numpy.zeros((nel,3),int) +- x=numpy.zeros((nx*ny,1)) +- y=numpy.zeros((nx*ny,1)) ++ x=numpy.zeros((nx*ny)) ++ y=numpy.zeros((nx*ny)) + + #create coordinates + for n in xrange(0,nx): +@@ -58,19 +58,19 @@ + #plug coordinates and nodes + md.mesh.x=x + md.mesh.y=y +- md.mesh.z=numpy.zeros((nods,1)) ++ md.mesh.z=numpy.zeros((nods)) + md.mesh.numberofvertices=nods +- md.mesh.vertexonboundary=numpy.zeros((nods,1),bool) ++ md.mesh.vertexonboundary=numpy.zeros((nods),bool) + md.mesh.vertexonboundary[segments[:,0:2]-1]=True +- md.mesh.vertexonbed=numpy.ones((nods,1),bool) +- md.mesh.vertexonsurface=numpy.ones((nods,1),bool) ++ md.mesh.vertexonbed=numpy.ones((nods),bool) ++ md.mesh.vertexonsurface=numpy.ones((nods),bool) + + #plug elements + md.mesh.elements=index + md.mesh.segments=segments + md.mesh.numberofelements=nel +- md.mesh.elementonbed=numpy.ones((nel,1),bool) +- md.mesh.elementonsurface=numpy.ones((nel,1),bool) ++ md.mesh.elementonbed=numpy.ones((nel),bool) ++ md.mesh.elementonsurface=numpy.ones((nel),bool) + + #Now, build the connectivity tables for this mesh. + [md.mesh.vertexconnectivity]=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices) +Index: ../trunk-jpl/src/m/mesh/ComputeMetric.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/ComputeMetric.py (revision 14094) ++++ ../trunk-jpl/src/m/mesh/ComputeMetric.py (revision 14095) +@@ -53,7 +53,7 @@ + + #take care of NaNs if any (use Numpy eig in a loop) + pos=numpy.nonzero(numpy.isnan(metric))[0] +- if pos: ++ if numpy.size(pos): + print(" %i NaN found in the metric. Use Numpy routine..." % numpy.size(pos)) + for posi in pos: + H=numpy.array([[hessian[posi,0],hessian[posi,1]],[hessian[posi,1],hessian[posi,2]]]) +Index: ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py +=================================================================== +--- ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py (revision 14094) ++++ ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py (revision 14095) +@@ -11,6 +11,14 @@ + else: + return False + ++def ismac(): ++ import platform ++ ++ if 'Darwin' in platform.system(): ++ return True ++ else: ++ return False ++ + def strcmp(s1,s2): + + if s1 == s2: Index: /issm/oecreview/Archive/14064-14311/ISSM-14097-14098.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14097-14098.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14097-14098.diff (revision 14312) @@ -0,0 +1,183 @@ +Index: ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp +=================================================================== +--- ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp (revision 14097) ++++ ../trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp (revision 14098) +@@ -107,9 +107,16 @@ + if (PyArray_Check((PyArrayObject*)py_matrix)) { + /*retrieve dimensions: */ + ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); +- if(ndim!=2)_error_("expecting an MxN matrix in input!"); +- dims=PyArray_DIMS((PyArrayObject*)py_matrix); +- M=dims[0]; N=dims[1]; ++ if (ndim==2) { ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=dims[1]; ++ } ++ else if (ndim==1) { ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=1; ++ } ++ else ++ _error_("expecting an MxN matrix or M vector in input!"); + + if (M && N) { + if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { +@@ -140,7 +147,7 @@ + } + + else +- _error_("unrecognized pyarray type in input!"); ++ _error_("unrecognized float pyarray type in input!"); + } + else + matrix=NULL; +@@ -177,9 +184,16 @@ + if (PyArray_Check((PyArrayObject*)py_matrix)) { + /*retrieve dimensions: */ + ndim=PyArray_NDIM((const PyArrayObject*)py_matrix); +- if(ndim!=2)_error_("expecting an MxN matrix in input!"); +- dims=PyArray_DIMS((PyArrayObject*)py_matrix); +- M=dims[0]; N=dims[1]; ++ if (ndim==2) { ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=dims[1]; ++ } ++ else if (ndim==1) { ++ dims=PyArray_DIMS((PyArrayObject*)py_matrix); ++ M=dims[0]; N=1; ++ } ++ else ++ _error_("expecting an MxN matrix or M vector in input!"); + + if (M && N) { + if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) { +@@ -210,7 +224,7 @@ + } + + else +- _error_("unrecognized pyarray type in input!"); ++ _error_("unrecognized long pyarray type in input!"); + } + else + matrix=NULL; +Index: ../trunk-jpl/src/m/geometry/FlagElements.py +=================================================================== +--- ../trunk-jpl/src/m/geometry/FlagElements.py (revision 14097) ++++ ../trunk-jpl/src/m/geometry/FlagElements.py (revision 14098) +@@ -46,7 +46,7 @@ + flag=numpy.prod(flag_nodes[md.mesh.elements],axis=1).astype(bool) + else: + #ok, flag elements +- [flag,dum]=ContourToMesh(md.mesh.elements[:,0:3].copy(),md.mesh.x.reshape(-1,1),md.mesh.y.reshape(-1,1),region,'element',1) ++ [flag,dum]=ContourToMesh(md.mesh.elements[:,0:3].copy(),md.mesh.x,md.mesh.y,region,'element',1) + flag=flag.astype(bool) + + if invert: +Index: ../trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.py (revision 14097) ++++ ../trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.py (revision 14098) +@@ -15,7 +15,7 @@ + for rift in md.rifts.riftstruct: + + #first, flag nodes that belong to the domain outline +- flags=ContourToMesh(md.mesh.elements,md.mesh.x.reshape(-1,1),md.mesh.y.reshape(-1,1),domainoutline,'node',0) ++ flags=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,domainoutline,'node',0) + + tips=rift.tips + outsidetips=tips[numpy.nonzero(flags[rift.tips-1])[0]] +Index: ../trunk-jpl/src/m/mesh/rifts/meshprocessrifts.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/rifts/meshprocessrifts.py (revision 14097) ++++ ../trunk-jpl/src/m/mesh/rifts/meshprocessrifts.py (revision 14098) +@@ -48,7 +48,7 @@ + rift['tip2coordinates']=numpy.hstack((md.mesh.x[rift['tips'][0,1].astype(int)-1].reshape(-1,1),md.mesh.y[rift['tips'][0,1].astype(int)-1].reshape(-1,1))) + + #In case we have rifts that open up the domain outline, we need to open them: +- [flags,dum]=ContourToMesh(md.mesh.elements,md.mesh.x.reshape(-1,1),md.mesh.y.reshape(-1,1),domainoutline,'node',0) ++ [flags,dum]=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,domainoutline,'node',0) + found=0 + for rift in md.rifts.riftstruct: + if flags[rift['tips'][0,0].astype(int)-1]==0: +Index: ../trunk-jpl/src/m/mesh/bamg.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/bamg.py (revision 14097) ++++ ../trunk-jpl/src/m/mesh/bamg.py (revision 14098) +@@ -91,7 +91,7 @@ + + #Checks that all holes are INSIDE the principle domain outline + if i: +- flags=ContourToNodes(domaini['x'].reshape(-1,1),domaini['y'].reshape(-1,1),domainfile,0) ++ flags=ContourToNodes(domaini['x'],domaini['y'],domainfile,0) + if numpy.any(numpy.logical_not(flags)): + raise RuntimeError("bamg error message: All holes should be strictly inside the principal domain") + +@@ -117,7 +117,7 @@ + for i,rifti in enumerate(rift): + + #detect whether all points of the rift are inside the domain +- flags=ContourToNodes(rifti['x'].reshape(-1,1),rifti['y'].reshape(-1,1),domain[0],0) ++ flags=ContourToNodes(rifti['x'],rifti['y'],domain[0],0) + if numpy.all(numpy.logical_not(flags)): + raise RuntimeError("one rift has all its points outside of the domain outline") + +Index: ../trunk-jpl/src/m/mesh/ComputeMetric.py +=================================================================== +--- ../trunk-jpl/src/m/mesh/ComputeMetric.py (revision 14097) ++++ ../trunk-jpl/src/m/mesh/ComputeMetric.py (revision 14098) +@@ -18,9 +18,9 @@ + d=hessian[:,2] + lambda1=0.5*((a+d)+numpy.sqrt(4.*b**2+(a-d)**2)) + lambda2=0.5*((a+d)-numpy.sqrt(4.*b**2+(a-d)**2)) +- pos1=numpy.nonzero(lambda1==0)[0] +- pos2=numpy.nonzero(lambda2==0)[0] +- pos3=numpy.nonzero(numpy.logical_and(b==0,lambda1==lambda2))[0] ++ pos1=numpy.nonzero(lambda1==0.)[0] ++ pos2=numpy.nonzero(lambda2==0.)[0] ++ pos3=numpy.nonzero(numpy.logical_and(b==0.,lambda1==lambda2))[0] + + #Modify the eigen values to control the shape of the elements + lambda1=numpy.minimum(numpy.maximum(numpy.abs(lambda1)*scale/epsilon,1./hmax**2),1./hmin**2) +Index: ../trunk-jpl/src/m/mesh/ComputeMetric.m +=================================================================== +--- ../trunk-jpl/src/m/mesh/ComputeMetric.m (revision 14097) ++++ ../trunk-jpl/src/m/mesh/ComputeMetric.m (revision 14098) +@@ -12,9 +12,9 @@ + a=hessian(:,1); b=hessian(:,2); d=hessian(:,3); + lambda1=0.5*((a+d)+sqrt(4.*b.^2+(a-d).^2)); + lambda2=0.5*((a+d)-sqrt(4.*b.^2+(a-d).^2)); +-pos1=find(lambda1==0); +-pos2=find(lambda2==0); +-pos3=find(b==0 & lambda1==lambda2); ++pos1=find(lambda1==0.); ++pos2=find(lambda2==0.); ++pos3=find(b==0. & lambda1==lambda2); + + %Modify the eigen values to control the shape of the elements + lambda1=min(max(abs(lambda1)*scale/epsilon,1./hmax^2),1./hmin^2); +Index: ../trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py +=================================================================== +--- ../trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 14097) ++++ ../trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 14098) +@@ -24,7 +24,7 @@ + if icefrontfile: + if not os.path.exists(icefrontfile): + raise IOError("SetIceShelfBC error message: ice front file '%s' not found." % icefrontfile) +- [nodeinsideicefront,dum]=ContourToMesh(md.mesh.elements,md.mesh.x.reshape(-1,1),md.mesh.y.reshape(-1,1),icefrontfile,'node',2) ++ [nodeinsideicefront,dum]=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,icefrontfile,'node',2) + nodeonicefront=numpy.logical_and(md.mesh.vertexonboundary,nodeinsideicefront.reshape(-1)) + else: + nodeonicefront=numpy.zeros((md.mesh.numberofvertices),bool) +Index: ../trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py +=================================================================== +--- ../trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 14097) ++++ ../trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 14098) +@@ -26,7 +26,7 @@ + #User provided Front.exp, use it + if not os.path.exists(icefrontfile): + raise IOError("SetMarineIceSheetBC error message: ice front file '%s' not found." % icefrontfile) +- [nodeinsideicefront,dum]=ContourToMesh(md.mesh.elements,md.mesh.x.reshape(-1,1),md.mesh.y.reshape(-1,1),icefrontfile,'node',2) ++ [nodeinsideicefront,dum]=ContourToMesh(md.mesh.elements,md.mesh.x,md.mesh.y,icefrontfile,'node',2) + vertexonicefront=numpy.logical_and(md.mesh.vertexonboundary,nodeinsideicefront.reshape(-1)) + else: + #Guess where the ice front is Index: /issm/oecreview/Archive/14064-14311/ISSM-14098-14099.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14098-14099.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14098-14099.diff (revision 14312) @@ -0,0 +1,32 @@ +Index: ../trunk-jpl/src/c/classes/objects/Vertex.cpp +=================================================================== +--- ../trunk-jpl/src/c/classes/objects/Vertex.cpp (revision 14098) ++++ ../trunk-jpl/src/c/classes/objects/Vertex.cpp (revision 14099) +@@ -196,17 +196,18 @@ + /*FUNCTION Vertex::ToXYZ {{{*/ + void Vertex::ToXYZ(Matrix* matrix){ + +- int i; +- double xyz[3]; +- int indices[3]; ++ IssmDouble xyz[3]; ++ int indices[3]; + +- if (this->clone==true)return; +- else{ ++ if (this->clone==true) return; + +- xyz[0]=x; xyz[1]=y; xyz[2]=z; +- indices[0]=0;indices[1]=1; indices[2]=2; ++ xyz[0]=x; ++ xyz[1]=y; ++ xyz[2]=z; ++ indices[0]=0; ++ indices[1]=1; ++ indices[2]=2; + +- matrix->SetValues(1,&sid,3,&indices[0],&xyz[0],INS_VAL); +- } ++ matrix->SetValues(1,&sid,3,&indices[0],&xyz[0],INS_VAL); + } + /*}}}*/ Index: /issm/oecreview/Archive/14064-14311/ISSM-14099-14100.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14099-14100.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14099-14100.diff (revision 14312) @@ -0,0 +1,35 @@ +Index: ../trunk-jpl/src/c/Container/Vertices.cpp +=================================================================== +--- ../trunk-jpl/src/c/Container/Vertices.cpp (revision 14099) ++++ ../trunk-jpl/src/c/Container/Vertices.cpp (revision 14100) +@@ -199,7 +199,7 @@ + } + /*}}}*/ + /*FUNCTION Vertices::ToXYZ{{{*/ +-double* Vertices::ToXYZ(void){ ++IssmDouble* Vertices::ToXYZ(void){ + + /*intermediary: */ + int i; +@@ -208,7 +208,7 @@ + + /*output: */ + Matrix* xyz = NULL; +- double* xyz_serial=NULL; ++ IssmDouble* xyz_serial=NULL; + + /*recover my_rank:*/ + my_rank=IssmComm::GetRank(); +Index: ../trunk-jpl/src/c/Container/Vertices.h +=================================================================== +--- ../trunk-jpl/src/c/Container/Vertices.h (revision 14099) ++++ ../trunk-jpl/src/c/Container/Vertices.h (revision 14100) +@@ -27,7 +27,7 @@ + void FlagClones(int numberofnodes); + int NumberOfVertices(void); + void Ranks(int* ranks); +- double* ToXYZ(void); ++ IssmDouble* ToXYZ(void); + }; + + #endif //ifndef _VERTICES_H_ Index: /issm/oecreview/Archive/14064-14311/ISSM-14100-14101.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14100-14101.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14100-14101.diff (revision 14312) @@ -0,0 +1,153 @@ +Index: ../trunk-jpl/src/m/classes/plotoptions.m +=================================================================== +--- ../trunk-jpl/src/m/classes/plotoptions.m (revision 14100) ++++ ../trunk-jpl/src/m/classes/plotoptions.m (revision 14101) +@@ -67,7 +67,7 @@ + opt.figurenumber=getfieldvalue(rawoptions,'figure',1); + + %get number of data to be plotted +- numberofplots=fieldoccurences(rawoptions,'data'); ++ numberofplots=fieldoccurrences(rawoptions,'data'); + opt.numberofplots=numberofplots; + + %figure out wether alloptions flog is on +Index: ../trunk-jpl/src/m/classes/settings.py +=================================================================== +--- ../trunk-jpl/src/m/classes/settings.py (revision 14100) ++++ ../trunk-jpl/src/m/classes/settings.py (revision 14101) +@@ -55,8 +55,8 @@ + #this option can be activated to load automatically the results + #onto the model after a parallel run by waiting for the lock file + #N minutes that is generated once the solution has converged +- #0 to desactivate +- self.waitonlock=float('Inf') ++ #0 to deactivate ++ self.waitonlock=2**31-1 + + return self + #}}} +Index: ../trunk-jpl/src/m/classes/pairoptions.m +=================================================================== +--- ../trunk-jpl/src/m/classes/pairoptions.m (revision 14100) ++++ ../trunk-jpl/src/m/classes/pairoptions.m (revision 14101) +@@ -83,7 +83,7 @@ + function obj = changefieldvalue(obj,field,newvalue) % {{{ + %CHANGEOPTIONVALUE - change the value of an option in an option list + +- %track occurance of field ++ %track occurrence of field + lines=find(strcmpi(obj.list(:,1),field)); + + %replace value +@@ -99,7 +99,7 @@ + function obj = deleteduplicates(obj,warn) % {{{ + %DELETEDUPLICATES - delete duplicates in an option list + +- %track the first occurance of each option ++ %track the first occurrence of each option + [dummy lines]=unique(obj.list(:,1),'first'); + clear dummy + +@@ -108,7 +108,7 @@ + numoptions=size(obj.list,1); + for i=1:numoptions, + if ~ismember(i,lines), +- disp(['WARNING: option ' obj.list{i,1} ' appeared more than once. Only its first occurence will be kept']) ++ disp(['WARNING: option ' obj.list{i,1} ' appeared more than once. Only its first occurrence will be kept']) + end + end + end +@@ -136,7 +136,7 @@ + end + end % }}} + function bool = exist(obj,field) % {{{ +- %EXIST - check if the option exist ++ %EXIST - check if the option exists + + %some argument checking: + if ((nargin~=2) | (nargout~=1)), +@@ -149,15 +149,15 @@ + %Recover option + bool=any(strcmpi(field,obj.list(:,1))); + end % }}} +- function num = fieldoccurences(obj,field), % {{{ +- %FIELDOCCURENCES - get number of occurence of a field ++ function num = fieldoccurrences(obj,field), % {{{ ++ %FIELDOCCURRENCES - get number of occurrence of a field + + %check input + if ~ischar(field), +- error('fieldoccurences error message: field should be a string'); ++ error('fieldoccurrences error message: field should be a string'); + end + +- %get number of occurence ++ %get number of occurrence + num=sum(strcmpi(field,obj.list(:,1))); + end % }}} + function value = getfieldvalue(obj,field,varargin), % {{{ +@@ -203,7 +203,7 @@ + % Usage: + % obj=removefield(obj,field,warn) + % +- % if warn==1 display an info message to wan user that ++ % if warn==1 display an info message to warn user that + % some of his options have been removed. + + %check is field exist +Index: ../trunk-jpl/src/m/classes/settings.m +=================================================================== +--- ../trunk-jpl/src/m/classes/settings.m (revision 14100) ++++ ../trunk-jpl/src/m/classes/settings.m (revision 14101) +@@ -37,7 +37,7 @@ + %this option can be activated to load automatically the results + %onto the model after a parallel run by waiting for the lock file + %N minutes that is generated once the solution has converged +- %0 to desactivate ++ %0 to deactivate + obj.waitonlock=Inf; + end % }}} + function md = checkconsistency(obj,md,solution,analyses) % {{{ +Index: ../trunk-jpl/src/m/classes/pairoptions.py +=================================================================== +--- ../trunk-jpl/src/m/classes/pairoptions.py (revision 14100) ++++ ../trunk-jpl/src/m/classes/pairoptions.py (revision 14101) +@@ -77,7 +77,7 @@ + # function obj = deleteduplicates(obj,warn) % {{{ + # %DELETEDUPLICATES - delete duplicates in an option list + # +-# %track the first occurance of each option ++# %track the first occurrence of each option + # [dummy lines]=unique(obj.list(:,1),'first'); + # clear dummy + # +@@ -86,7 +86,7 @@ + # numoptions=size(obj.list,1); + # for i=1:numoptions, + # if ~ismember(i,lines), +-# disp(['WARNING: option ' obj.list{i,1} ' appeared more than once. Only its first occurence will be kept']) ++# disp(['WARNING: option ' obj.list{i,1} ' appeared more than once. Only its first occurrence will be kept']) + # end + # end + # end +@@ -127,16 +127,16 @@ + return False + # }}} + +- #def fieldoccurences(self,field): #{{{ ++ #def fieldoccurrences(self,field): #{{{ + # ''' +- # FIELDOCCURENCES - get number of occurence of a field ++ # FIELDOCCURRENCES - get number of occurrence of a field + # ''' + # + # #check input + # if not isinstance(field,(str,unicode)): +- # raise TypeError("fieldoccurences error message: field should be a string") ++ # raise TypeError("fieldoccurrences error message: field should be a string") + +- # #get number of occurence ++ # #get number of occurrence + # # ?? + # #return num + # #% }}} Index: /issm/oecreview/Archive/14064-14311/ISSM-14101-14102.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14101-14102.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14101-14102.diff (revision 14312) @@ -0,0 +1,1227 @@ +Index: ../trunk-jpl/test/Par/SquareThermal.par +=================================================================== +--- ../trunk-jpl/test/Par/SquareThermal.par (revision 14101) ++++ ../trunk-jpl/test/Par/SquareThermal.par (revision 14102) +@@ -3,9 +3,9 @@ + md.timestepping.time_step=0; + + disp(' creating thickness'); +-h=1000; ++h=1000.; + md.geometry.thickness=h*ones(md.mesh.numberofvertices,1); +-md.geometry.bed=-1000*ones(md.mesh.numberofvertices,1); ++md.geometry.bed=-1000.*ones(md.mesh.numberofvertices,1); + md.geometry.surface=md.geometry.bed+md.geometry.thickness; + + disp(' creating velocities'); +@@ -14,23 +14,23 @@ + md.initialization.vz=zeros(md.mesh.numberofvertices,1); + + disp(' creating drag'); +-md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1. ++md.friction.coefficient=200.*ones(md.mesh.numberofvertices,1); %q=1. + %Take care of iceshelves: no basal drag + pos=find(md.mask.elementonfloatingice); +-md.friction.coefficient(md.mesh.elements(pos,:))=0; ++md.friction.coefficient(md.mesh.elements(pos,:))=0.; + md.friction.p=ones(md.mesh.numberofelements,1); + md.friction.q=ones(md.mesh.numberofelements,1); + + disp(' creating temperatures'); +-md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1); ++md.initialization.temperature=(273.-20.)*ones(md.mesh.numberofvertices,1); + +-disp(' creating flow law paramter'); ++disp(' creating flow law parameter'); + md.materials.rheology_B=paterson(md.initialization.temperature); +-md.materials.rheology_n=3*ones(md.mesh.numberofelements,1); ++md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); + + disp(' creating surface mass balance'); + md.surfaceforcings.mass_balance=ones(md.mesh.numberofvertices,1)/md.constants.yts; %1m/a +-md.basalforcings.melting_rate=0*ones(md.mesh.numberofvertices,1)/md.constants.yts; %1m/a ++md.basalforcings.melting_rate=0.*ones(md.mesh.numberofvertices,1)/md.constants.yts; %1m/a + + %Deal with boundary conditions: + +@@ -40,4 +40,4 @@ + disp(' boundary conditions for thermal model'); + md.thermal.spctemperature(:)=md.initialization.temperature; + md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1); +-pos=find(md.mask.elementongroundedice);md.basalforcings.geothermalflux(md.mesh.elements(pos,:))=1*10^-3; %1 mW/m^2 ++pos=find(md.mask.elementongroundedice);md.basalforcings.geothermalflux(md.mesh.elements(pos,:))=1.*10^-3; %1 mW/m^2 +Index: ../trunk-jpl/test/Par/SquareSheetShelf.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareSheetShelf.py (revision 14101) ++++ ../trunk-jpl/test/Par/SquareSheetShelf.py (revision 14102) +@@ -56,7 +56,7 @@ + md.prognostic.stabilization=1 + md.thermal.stabilization=1 + md.verbose=verbose(0) +-md.settings.waitonlock=30. ++md.settings.waitonlock=30 + md.diagnostic.restol=0.05 + md.steadystate.reltol=0.05 + md.diagnostic.reltol=0.05 +Index: ../trunk-jpl/test/Par/SquareShelfConstrained.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareShelfConstrained.py (revision 14101) ++++ ../trunk-jpl/test/Par/SquareShelfConstrained.py (revision 14102) +@@ -54,7 +54,7 @@ + md.prognostic.stabilization=1. + md.thermal.stabilization=1. + md.verbose = verbose(0) +-md.settings.waitonlock=30. ++md.settings.waitonlock=30 + md.diagnostic.restol=0.05 + md.diagnostic.reltol=0.05 + md.steadystate.reltol=0.05 +Index: ../trunk-jpl/test/Par/SquareThermal.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareThermal.py (revision 0) ++++ ../trunk-jpl/test/Par/SquareThermal.py (revision 14102) +@@ -0,0 +1,48 @@ ++import numpy ++from paterson import * ++from SetMarineIceSheetBC import * ++ ++#Ok, start defining model parameters here ++ ++md.timestepping.time_step=0 ++ ++print " creating thickness" ++h=1000. ++md.geometry.thickness=h*numpy.ones((md.mesh.numberofvertices,1)) ++md.geometry.bed=-1000.*numpy.ones((md.mesh.numberofvertices,1)) ++md.geometry.surface=md.geometry.bed+md.geometry.thickness; ++ ++print " creating velocities" ++md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vy=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vz=numpy.zeros((md.mesh.numberofvertices,1)) ++ ++print " creating drag" ++md.friction.coefficient=200.*numpy.ones((md.mesh.numberofvertices,1)) #q=1. ++#Take care of iceshelves: no basal drag ++pos=numpy.nonzero(md.mask.elementonfloatingice)[0] ++md.friction.coefficient[md.mesh.elements[pos,:]-1]=0. ++md.friction.p=numpy.ones((md.mesh.numberofelements,1)) ++md.friction.q=numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating temperatures" ++md.initialization.temperature=(273.-20.)*numpy.ones((md.mesh.numberofvertices,1)) ++ ++print " creating flow law parameter" ++md.materials.rheology_B=paterson(md.initialization.temperature) ++md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating surface mass balance" ++md.surfaceforcings.mass_balance=numpy.ones((md.mesh.numberofvertices,1))/md.constants.yts #1m/a ++md.basalforcings.melting_rate=0.*numpy.ones((md.mesh.numberofvertices,1))/md.constants.yts #1m/a ++ ++#Deal with boundary conditions: ++ ++print " boundary conditions for diagnostic model" ++md=SetMarineIceSheetBC(md,'../Exp/SquareFront.exp') ++ ++print " boundary conditions for thermal model" ++md.thermal.spctemperature[:]=md.initialization.temperature ++md.basalforcings.geothermalflux=numpy.zeros((md.mesh.numberofvertices,1)) ++pos=numpy.nonzero(md.mask.elementongroundedice)[0] ++md.basalforcings.geothermalflux[md.mesh.elements[pos,:]-1]=1.*10**-3 #1 mW/m^2 + +Property changes on: ../trunk-jpl/test/Par/SquareThermal.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/Par/Pig.py +=================================================================== +--- ../trunk-jpl/test/Par/Pig.py (revision 14101) ++++ ../trunk-jpl/test/Par/Pig.py (revision 14102) +@@ -47,7 +47,7 @@ + md.diagnostic.viscosity_overshoot=0.3 + md.prognostic.stabilization=1. + md.verbose=verbose(0) +-md.settings.waitonlock=30. ++md.settings.waitonlock=30 + md.timestepping.time_step=1. + md.timestepping.final_time=2. + md.diagnostic.restol=0.05 +Index: ../trunk-jpl/test/Par/SquareShelf.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareShelf.py (revision 14101) ++++ ../trunk-jpl/test/Par/SquareShelf.py (revision 14102) +@@ -69,7 +69,7 @@ + md.diagnostic.viscosity_overshoot = 0.3 + md.prognostic.stabilization = 1. + md.thermal.stabilization = 1. +-md.settings.waitonlock = 30. ++md.settings.waitonlock = 30 + md.verbose=verbose() + md.diagnostic.restol = 0.10 + md.steadystate.reltol = 0.02 +Index: ../trunk-jpl/test/Par/SquareSheetConstrained.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareSheetConstrained.py (revision 14101) ++++ ../trunk-jpl/test/Par/SquareSheetConstrained.py (revision 14102) +@@ -50,7 +50,7 @@ + md.prognostic.stabilization=1. + md.thermal.stabilization=1. + md.verbose=verbose(0) +-md.settings.waitonlock=30. ++md.settings.waitonlock=30 + md.diagnostic.restol=0.05 + md.steadystate.reltol=0.05 + md.diagnostic.reltol=0.05 +Index: ../trunk-jpl/test/NightlyRun/test1304.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1304.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1304.py (revision 14102) +@@ -0,0 +1,59 @@ ++import numpy ++import sys ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++This file can be run to check that the geothermal flux in simple conduction is correctly modeled. ++There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature ++at upper surface and an impose flux at its base. The result must be a linear temperature from the upper to the lower ++surface with an imposed slope (Geothermal flux). if it is not the case, something is thermal modeling has been changed... ++""" ++ ++printingflag=False ++ ++md=model() ++md=triangle(md,'../Exp/Square.exp',100000.) ++md=setmask(md,'','') ++md=parameterize(md,'../Par/SquareThermal.py') ++md.extrude(11,1.) ++md=setflowequation(md,'pattyn','all') ++ ++pos2=numpy.nonzero(md.mesh.elementonsurface)[0] ++md.thermal.spctemperature[md.mesh.elements[pos2,3:6]-1]=0. ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1),int) ++md.basalforcings.geothermalflux[:]=0.1 #100mW/m^2 ++ ++#analytical results ++#the result is linear with depth and is equal to 0 on the upper surface (See BC) ++#d2T/dz2=0 -k*dT/dz(bed)=G T(surface)=0 => T=-G/k*(z-surface) ++md.initialization.temperature=-0.1/md.materials.thermalconductivity*(md.mesh.z-md.geometry.surface) #G=0.1 W/m2 ++ ++#modeled results ++md.cluster=generic('name',oshostname(),'np',2) ++md=solve(md,ThermalSolutionEnum()) ++ ++#plot results ++comp_temp=md.results.ThermalSolution.Temperature ++relative=numpy.abs((comp_temp-md.initialization.temperature)/md.initialization.temperature)*100. ++relative[numpy.nonzero(comp_temp==md.initialization.temperature)[0]]=0. ++#plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... ++# 'title','Analytical temperature','view',3,'data',comp_temp-md.initialization.temperature,... ++# 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... ++# 'figposition','mathieu','FontSize#all',20) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('thermalgeothermalflux','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); ++# system(['mv thermalgeothermalflux.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); ++ ++#Fields and tolerances to track changes ++field_names =['GeothermalFluxTemperature'] ++field_tolerances=[1e-13] ++field_values =[comp_temp] + +Property changes on: ../trunk-jpl/test/NightlyRun/test1304.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/NightlyRun/test1301.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1301.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1301.m (revision 14102) +@@ -9,7 +9,7 @@ + md=setmask(md,'',''); + md=parameterize(md,'../Par/SquareThermal.par'); + md=extrude(md,3,2.); +-md=setflowequation(md,'Pattyn','all'); ++md=setflowequation(md,'pattyn','all'); + + %Some conditions specific to melting test + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); +@@ -23,24 +23,23 @@ + %Mb*L*rho=G => Mb=G/L*rho + melting=md.basalforcings.geothermalflux/(md.materials.rho_ice*md.materials.latentheat)*md.constants.yts; + +-%modeled results ++%modeled results + md.cluster=generic('name',oshostname(),'np',2); + md=solve(md,ThermalSolutionEnum()); + + %plot results + comp_melting=md.results.ThermalSolution.BasalforcingsMeltingRate; +-relative=abs((comp_melting-melting)./melting)*100; +-relative(find(comp_melting==melting))=0; ++relative=abs((comp_melting-melting)./melting)*100.; ++relative(find(comp_melting==melting))=0.; + plotmodel(md,'data',comp_melting,'title','Modeled melting','data',melting,'title','Analytical melting',... + 'data',comp_melting-melting,'title','Absolute error','data',relative,'title','Relative error [%]',... + 'layer#all',1,'caxis#2',[1.02964 1.02966]*10^-4,'FontSize#all',20,'figposition','mathieu') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('thermalmelting','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); + system(['mv thermalmelting.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); + end + +- + %Fields and tolerances to track changes + field_names ={'BasalMelting'}; + field_tolerances={1e-08}; +Index: ../trunk-jpl/test/NightlyRun/test1302.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1302.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1302.m (revision 14102) +@@ -8,11 +8,11 @@ + md=setmask(md,'',''); + md=parameterize(md,'../Par/SquareThermal.par'); + md=extrude(md,30,1.); %NB: the more one extrudes, the better (10-> relative~0.35%, 20->0.1%, 30->0.05%) +-md=setflowequation(md,'Pattyn','all'); ++md=setflowequation(md,'pattyn','all'); + + %Thermal boundary conditions +-pos1=find(md.mesh.elementonbed); md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10; +-pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0; ++pos1=find(md.mesh.elementonbed); md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.; ++pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0.; + md.initialization.vz=0.1*ones(md.mesh.numberofvertices,1); + md.initialization.vel=sqrt( md.initialization.vx.^2+ md.initialization.vy.^2+ md.initialization.vz.^2); + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); +@@ -21,23 +21,23 @@ + %analytical results + %d2T/dz2-w*rho_ice*c/k*dT/dz=0 T(surface)=0 T(bed)=10 => T=A exp(alpha z)+B + alpha=0.1/md.constants.yts*md.materials.rho_ice*md.materials.heatcapacity/md.materials.thermalconductivity; %alpha=w rho_ice c /k and w=0.1m/an +-A=10/(exp(alpha*(-1000))-1); %A=T(bed)/(exp(alpha*bed)-1) with bed=-1000 T(bed)=10 ++A=10./(exp(alpha*(-1000.))-1.); %A=T(bed)/(exp(alpha*bed)-1) with bed=-1000 T(bed)=10 + B=-A; + md.initialization.temperature=A*exp(alpha*md.mesh.z)+B; + +-%modeled results ++%modeled results + md.cluster=generic('name',oshostname(),'np',2); + md=solve(md,ThermalSolutionEnum()); + + %plot results + comp_temp=md.results.ThermalSolution.Temperature; +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100; +-relative(find(comp_temp==md.initialization.temperature))=0; ++relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100.; ++relative(find(comp_temp==md.initialization.temperature))=0.; + plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... + 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,... + 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... + 'figposition','mathieu','FontSize#all',20) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('thermaladvection','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); + system(['mv thermaladvection.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT ']); +Index: ../trunk-jpl/test/NightlyRun/test1401.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1401.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1401.m (revision 14102) +@@ -1,36 +1,36 @@ + %test the anisotropic mesh adaptation +-%function to capture = exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++%function to capture = exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + printingflag=false; + + %create square mesh +-L=1; %in m ++L=1.; %in m + nx=70; %numberof nodes in x direction + ny=70; + md=model(); + + %mesh adaptation loop YAMS + md=squaremesh(md,L,L,nx,ny); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_yams1','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_yams1.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + +-md=YamsCall(md,md.inversion.vel_obs,0.001,0.3,1.3,10^-4); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md=YamsCall(md,md.inversion.vel_obs,0.001,0.3,1.3,10.^-4); ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_yams2','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_yams2.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + + md=YamsCall(md,md.inversion.vel_obs,0.001,0.3,2.5,0.008); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_yams3','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_yams3.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +@@ -40,19 +40,19 @@ + + %mesh adaptation loop BAMG + md=squaremesh(md,L,L,nx,ny); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_bamg1','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_bamg1.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + + md.private.bamg=NaN; +-md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.001,'hmax',0.3,'gradation',1.3,'err',10^-4); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.001,'hmax',0.3,'gradation',1.3,'err',10.^-4); ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_bamg2','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_bamg2.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +@@ -60,9 +60,9 @@ + + md.private.bamg=NaN; + md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.001,'hmax',0.3,'gradation',2.5,'err',0.008); +-md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2; ++md.inversion.vel_obs=exp(-(sqrt((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)-0.75).^2*10.^6)+((md.mesh.x+0.1).^2+(md.mesh.y+0.1).^2)/2.; + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh1_bamg3','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh1_bamg3.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +Index: ../trunk-jpl/test/NightlyRun/test1303.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1303.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1303.m (revision 14102) +@@ -9,29 +9,30 @@ + md=setmask(md,'all',''); + md=parameterize(md,'../Par/SquareThermal.par'); + md=extrude(md,11,2.); +-md=setflowequation(md,'Pattyn','all'); +-pos1=find(md.mesh.elementonbed); md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10; +-pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0; ++md=setflowequation(md,'pattyn','all'); ++ ++pos1=find(md.mesh.elementonbed); md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10.; ++pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0.; + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); + + %analytical results + %d2T/dz2=0 T(bed)=10 T(surface)=0 => T=0*(z-bed)/thickness+10*(surface-z)/thickness + %each layer of the 3d mesh must have a constant value +-md.initialization.temperature=10*(md.geometry.surface-md.mesh.z)./md.geometry.thickness; ++md.initialization.temperature=10.*(md.geometry.surface-md.mesh.z)./md.geometry.thickness; + +-%modeled results ++%modeled results + md.cluster=generic('name',oshostname(),'np',2); + md=solve(md,ThermalSolutionEnum()); + + %plot results + comp_temp=md.results.ThermalSolution.Temperature; +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100; +-relative(find(comp_temp==md.initialization.temperature))=0; ++relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100.; ++relative(find(comp_temp==md.initialization.temperature))=0.; + plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... + 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,... + 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... + 'figposition','mathieu','FontSize#all',20) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('thermalconduction','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); + system(['mv thermalconduction.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); +Index: ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1301.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1301.py (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1301.py (revision 14102) +@@ -1,87 +0,0 @@ +-""" +-== == == == == == == == == == == == == == == == == == == +-Auto generated python script for ISSM: test1301.m +-Created on 2012-09-27 via translateToPy.py Ver 1.0 by mikep +-== == == == == == == == == == == == == == == == == == == +- +-Matlab script conversion into python +-translateToPy.py Author: Michael Pellegrin +-translateToPy.py Date: 09/24/12 +-== == == == == == == == == == == == == == == == == == == +-""" +- +-from MatlabFuncs import * +-from model import * +-from EnumDefinitions import * +-from numpy import * +-from triangle import * +-from setmask import * +-from parameterize import * +-from setflowequation import * +-from solve import * +- +-# This file can be run to check that the melting in simple conduction is correctly modeled. +- +-# There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature +- +-# at upper surface and an impose flux at its base. The result must be a linear temperature from the upper to the lower +- +-# surface with an imposed slope (Geothermal flux). if it is not the case, something is thermal modeling has been changed... +- +-printingflag=false +- +- +-md=model() +-md=triangle(md,'../Exp/Square.exp',100000) +-md=setmask(md,'','') +-md=parameterize(md,'../Par/SquareThermal.py') +-md.extrude(3,2.) +-md=setflowequation(md,'Pattyn','all') +- +- +-# Some conditions specific to melting test +- +-md.initialization.pressure=zeros(md.mesh.numberofvertices,1) +-md.initialization.temperature=273.15*ones(md.mesh.numberofvertices,1) +-pos=numpy.nonzero(md.mesh.vertexonsurface) +-md.thermal.spctemperature(pos)=md.initialization.temperature(pos) +-md.materials.rheology_B=paterson(md.initialization.temperature) +- +- +-# analytical results +- +-# melting heat = geothermal flux +- +-# Mb*L*rho=G => Mb=G/L*rho +- +-melting=md.basalforcings.geothermalflux/(md.materials.rho_ice*md.materials.latentheat)*md.constants.yts +- +- +-# modeled results +- +-md.cluster=generic('name',oshostname(),'np',2) +-md=solve(md,ThermalSolutionEnum()) +- +- +-# plot results +- +-comp_melting=md.results.ThermalSolution.BasalforcingsMeltingRate +-relative=abs((comp_melting-melting)./melting)*100 +-relative(find(comp_melting==melting))=0 +-plotmodel()(md,'data',comp_melting,'title','Modeled melting','data',melting,'title','Analytical melting',\ +- 'data',comp_melting-melting,'title','Absolute error','data',relative,'title','Relative error [%]',\ +- 'layer#all',1,'caxis#2',[1.02964 1.02966]*10^-4,'FontSize#all',20,'figposition','mathieu') +-if printingflag, +- set(gcf,'Color','w') +- printmodel()('thermalmelting','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off') +- system(['mv thermalmelting.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']) +-end +- +- +- +- +-# Fields and tolerances to track changes +- +-field_names =['BasalMelting'] +-field_tolerances=[1e-08] +-field_values =[comp_melting] +Index: ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1302.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1302.py (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1302.py (revision 14102) +@@ -1,86 +0,0 @@ +-""" +-== == == == == == == == == == == == == == == == == == == +-Auto generated python script for ISSM: test1302.m +-Created on 2012-09-27 via translateToPy.py Ver 1.0 by mikep +-== == == == == == == == == == == == == == == == == == == +- +-Matlab script conversion into python +-translateToPy.py Author: Michael Pellegrin +-translateToPy.py Date: 09/24/12 +-== == == == == == == == == == == == == == == == == == == +-""" +- +-from MatlabFuncs import * +-from model import * +-from EnumDefinitions import * +-from numpy import * +-from triangle import * +-from setmask import * +-from parameterize import * +-from setflowequation import * +-from solve import * +- +-# This file can be run to check that the advection-diffusion is correctly modeled. +- +-# There is u=v=0 and w=cst everywhere the only thermal boundary conditions are an imposed temperature +- +-# at upper surface and an impose flux at its base. +- +-printingflag=false +- +- +-md=model() +-md=triangle(md,'../Exp/Square.exp',100000) +-md=setmask(md,'','') +-md=parameterize(md,'../Par/SquareThermal.py') +-md.extrude(30,1.) %NB: the more one extrudes, the better (10-> relative~0.35%, 20->0.1%, 30->0.05%.) +-md=setflowequation(md,'Pattyn','all') +- +- +-# Thermal boundary conditions +- +-pos1=numpy.nonzero(md.mesh.elementonbed) md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10 +-pos2=numpy.nonzero(md.mesh.elementonsurface) md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0 +-md.initialization.vz=0.1*ones(md.mesh.numberofvertices,1) +-md.initialization.vel=sqrt( md.initialization.vx.^2+ md.initialization.vy.^2+ md.initialization.vz.^2) +-md.initialization.pressure=zeros(md.mesh.numberofvertices,1) +- +- +-md.thermal.stabilization=2 +-# analytical results +- +-# d2T/dz2-w*rho_ice*c/k*dT/dz=0 T(surface)=0 T(bed)=10 => T=A exp(alpha z)+B +- +-alpha=0.1/md.constants.yts*md.materials.rho_ice*md.materials.heatcapacity/md.materials.thermalconductivity %alpha=w rho_ice c /k and w=0.1m/an +-A=10/(exp(alpha*(-1000))-1) %A=T(bed)/(exp(alpha*bed)-1) with bed=-1000 T(bed)=10 +-B=-A +-md.initialization.temperature=A*exp(alpha*md.mesh.z)+B +- +- +-# modeled results +- +-md.cluster=generic('name',oshostname(),'np',2) +-md=solve(md,ThermalSolutionEnum()) +- +- +-# plot results +- +-comp_temp=md.results.ThermalSolution.Temperature +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100 +-relative(find(comp_temp==md.initialization.temperature))=0 +-plotmodel()(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,\ +- 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,\ +- 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,\ +- 'figposition','mathieu','FontSize#all',20) +-if printingflag, +- set(gcf,'Color','w') +- printmodel()('thermaladvection','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off') +- system(['mv thermaladvection.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT ']) +-end +- +- +-# Fields and tolerances to track changes +- +-field_names =['AdvectionTemperature'] +-field_tolerances=[1e-13] +-field_values =[comp_temp] +Index: ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1303.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1303.py (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1303.py (revision 14102) +@@ -1,80 +0,0 @@ +-""" +-== == == == == == == == == == == == == == == == == == == +-Auto generated python script for ISSM: test1303.m +-Created on 2012-09-27 via translateToPy.py Ver 1.0 by mikep +-== == == == == == == == == == == == == == == == == == == +- +-Matlab script conversion into python +-translateToPy.py Author: Michael Pellegrin +-translateToPy.py Date: 09/24/12 +-== == == == == == == == == == == == == == == == == == == +-""" +- +-from MatlabFuncs import * +-from model import * +-from EnumDefinitions import * +-from numpy import * +-from triangle import * +-from setmask import * +-from parameterize import * +-from setflowequation import * +-from solve import * +- +-# This file can be run to check that the conduction is correctly modeled. +- +-# There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature +- +-# at the lower and upper surface. The result must be a linear temperature from the upper to the lower +- +-# surface. if it is not the case, something is thermal modeling has been changed... +- +-printingflag=false +- +- +-md=model() +-md=triangle(md,'../Exp/Square.exp',100000) +-md=setmask(md,'all','') +-md=parameterize(md,'../Par/SquareThermal.py') +-md.extrude(11,2.) +-md=setflowequation(md,'Pattyn','all') +-pos1=numpy.nonzero(md.mesh.elementonbed) md.thermal.spctemperature(md.mesh.elements(pos1,1:3))=10 +-pos2=numpy.nonzero(md.mesh.elementonsurface) md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0 +-md.initialization.pressure=zeros(md.mesh.numberofvertices,1) +- +- +-# analytical results +- +-# d2T/dz2=0 T(bed)=10 T(surface)=0 => T=0*(z-bed)/thickness+10*(surface-z)/thickness +- +-# each layer of the 3d mesh must have a constant value +- +-md.initialization.temperature=10*(md.geometry.surface-md.mesh.z)./md.geometry.thickness +- +- +-# modeled results +- +-md.cluster=generic('name',oshostname(),'np',2) +-md=solve(md,ThermalSolutionEnum()) +- +- +-# plot results +- +-comp_temp=md.results.ThermalSolution.Temperature +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100 +-relative(find(comp_temp==md.initialization.temperature))=0 +-plotmodel()(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,\ +- 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,\ +- 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,\ +- 'figposition','mathieu','FontSize#all',20) +-if printingflag, +- set(gcf,'Color','w') +- printmodel()('thermalconduction','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off') +- system(['mv thermalconduction.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']) +-end +- +- +-# Fields and tolerances to track changes +- +-field_names =['ConductionTemperature'] +-field_tolerances=[1e-13] +-field_values =[comp_temp] +Index: ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1304.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1304.py (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/InNeedOfDebugging/test1304.py (revision 14102) +@@ -1,82 +0,0 @@ +-""" +-== == == == == == == == == == == == == == == == == == == +-Auto generated python script for ISSM: test1304.m +-Created on 2012-09-27 via translateToPy.py Ver 1.0 by mikep +-== == == == == == == == == == == == == == == == == == == +- +-Matlab script conversion into python +-translateToPy.py Author: Michael Pellegrin +-translateToPy.py Date: 09/24/12 +-== == == == == == == == == == == == == == == == == == == +-""" +- +-from MatlabFuncs import * +-from model import * +-from EnumDefinitions import * +-from numpy import * +-from triangle import * +-from setmask import * +-from parameterize import * +-from setflowequation import * +-from solve import * +- +-# This file can be run to check that the geothermal flux in simple conduction is correctly modeled. +- +-# There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature +- +-# at upper surface and an impose flux at its base. The result must be a linear temperature from the upper to the lower +- +-# surface with an imposed slope (Geothermal flux). if it is not the case, something is thermal modeling has been changed... +- +-printingflag=false +- +- +-md=model() +-md=triangle(md,'../Exp/Square.exp',100000) +-md=setmask(md,'','') +-md=parameterize(md,'../Par/SquareThermal.py') +-md.extrude(11,1.) +-md=setflowequation(md,'Pattyn','all') +- +- +-pos2=numpy.nonzero(md.mesh.elementonsurface) md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0 +-md.initialization.pressure=zeros(md.mesh.numberofvertices,1) +-md.basalforcings.geothermalflux(:)=0.1 %100mW/m^2 +- +- +-# analytical results +- +-# the result is linear with depth and is equal to 0 on the upper surface (See BC) +- +-# d2T/dz2=0 -k*dT/dz(bed)=G T(surface)=0 => T=-G/k*(z-surface) +- +-md.initialization.temperature=-0.1/md.materials.thermalconductivity*(md.mesh.z-md.geometry.surface) %G=0.1 W/m2 +- +- +-# modeled results +- +-md.cluster=generic('name',oshostname(),'np',2) +-md=solve(md,ThermalSolutionEnum()) +- +- +-# plot results +- +-comp_temp=md.results.ThermalSolution.Temperature +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100 +-relative(find(comp_temp==md.initialization.temperature))=0 +-plotmodel()(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,\ +- 'title','Analytical temperature','view',3,'data',comp_temp-md.initialization.temperature,\ +- 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,\ +- 'figposition','mathieu','FontSize#all',20) +-if printingflag, +- set(gcf,'Color','w') +- printmodel()('thermalgeothermalflux','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off') +- system(['mv thermalgeothermalflux.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']) +-end +- +- +-# Fields and tolerances to track changes +- +-field_names =['GeothermalFluxTemperature'] +-field_tolerances=[1e-13] +-field_values =[comp_temp] +Index: ../trunk-jpl/test/NightlyRun/test1402.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1402.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1402.m (revision 14102) +@@ -2,43 +2,43 @@ + printingflag=false; + + %create square mesh +-L=1; %in m ++L=1.; %in m + nx=30; %numberof nodes in x direction + ny=30; + md=model(); + + %mesh adaptation loop YAMS + md=squaremesh(md,L,L,nx,ny); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_yams1','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_yams1.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + +-md=YamsCall(md,md.inversion.vel_obs,0.005,0.3,2.3,10^-2); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++md=YamsCall(md,md.inversion.vel_obs,0.005,0.3,2.3,10.^2); ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_yams2','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_yams2.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + + md=YamsCall(md,md.inversion.vel_obs,0.005,0.3,3,0.005); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_yams3','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_yams3.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +@@ -48,25 +48,25 @@ + + %mesh adaptation loop BAMG + md=squaremesh(md,L,L,nx,ny); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_bamg1','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_bamg1.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); + end + + md.private.bamg=NaN; +-md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.005,'hmax',0.3,'gradation',2.3,'err',10^-2); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.005,'hmax',0.3,'gradation',2.3,'err',10.^2); ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_bamg2','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_bamg2.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +@@ -74,12 +74,12 @@ + + md.private.bamg=NaN; + md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.005,'hmax',0.3,'gradation',3,'err',0.005); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_bamg3','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_bamg3.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +@@ -87,12 +87,12 @@ + + md.private.bamg=NaN; + md=bamg(md,'field',md.inversion.vel_obs,'hmin',0.005,'hmax',0.3,'gradation',1.5,'err',0.003,'anisomax',1); +-u=4*md.mesh.x-2; v=4*md.mesh.y-2; +-md.inversion.vel_obs=tanh(30*(u.^2+v.^2-0.25)) ... +- +tanh(30*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u-0.75).^2+(v+0.75).^2-0.25)) ... +- +tanh(30*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30*((u+0.75).^2+(v+0.75).^2-0.25)) ; ++u=4.*md.mesh.x-2.; v=4.*md.mesh.y-2.; ++md.inversion.vel_obs=tanh(30.*(u.^2+v.^2-0.25)) ... ++ +tanh(30.*((u-0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u-0.75).^2+(v+0.75).^2-0.25)) ... ++ +tanh(30.*((u+0.75).^2+(v-0.75).^2-0.25)) +tanh(30.*((u+0.75).^2+(v+0.75).^2-0.25)); + plotmodel(md,'data',md.inversion.vel_obs,'data',md.inversion.vel_obs,'nlines',1,'ncols',2,'title','','figposition',[500 500 1000 500],'axis#all','equal','xlim#all',[0 1],'ylim#all',[0 1],'edgecolor#1','w'); pause(0.5); +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('mesh2_bamgiso','png','margin','on','marginsize',25,'frame','off','resolution',1,'hardcopy','off'); + system(['mv mesh2_bamgiso.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Mesh/ ']); +Index: ../trunk-jpl/test/NightlyRun/test1304.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1304.m (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/test1304.m (revision 14102) +@@ -9,9 +9,9 @@ + md=setmask(md,'',''); + md=parameterize(md,'../Par/SquareThermal.par'); + md=extrude(md,11,1.); +-md=setflowequation(md,'Pattyn','all'); ++md=setflowequation(md,'pattyn','all'); + +-pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0; ++pos2=find(md.mesh.elementonsurface); md.thermal.spctemperature(md.mesh.elements(pos2,4:6))=0.; + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); + md.basalforcings.geothermalflux(:)=0.1; %100mW/m^2 + +@@ -20,19 +20,19 @@ + %d2T/dz2=0 -k*dT/dz(bed)=G T(surface)=0 => T=-G/k*(z-surface) + md.initialization.temperature=-0.1/md.materials.thermalconductivity*(md.mesh.z-md.geometry.surface); %G=0.1 W/m2 + +-%modeled results ++%modeled results + md.cluster=generic('name',oshostname(),'np',2); + md=solve(md,ThermalSolutionEnum()); + + %plot results + comp_temp=md.results.ThermalSolution.Temperature; +-relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100; +-relative(find(comp_temp==md.initialization.temperature))=0; ++relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100.; ++relative(find(comp_temp==md.initialization.temperature))=0.; + plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... + 'title','Analytical temperature','view',3,'data',comp_temp-md.initialization.temperature,... + 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... + 'figposition','mathieu','FontSize#all',20) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('thermalgeothermalflux','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); + system(['mv thermalgeothermalflux.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); +Index: ../trunk-jpl/test/NightlyRun/test1301.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1301.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1301.py (revision 14102) +@@ -0,0 +1,60 @@ ++import numpy ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from paterson import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++This file can be run to check that the melting in simple conduction is correctly modeled. ++There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature ++at upper surface and an impose flux at its base. The result must be a linear temperature from the upper to the lower ++surface with an imposed slope (Geothermal flux). if it is not the case, something is thermal modeling has been changed... ++""" ++ ++printingflag=False ++ ++md=model() ++md=triangle(md,'../Exp/Square.exp',100000.) ++md=setmask(md,'','') ++md=parameterize(md,'../Par/SquareThermal.py') ++md.extrude(3,2.) ++md=setflowequation(md,'pattyn','all') ++ ++#Some conditions specific to melting test ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1),int) ++md.initialization.temperature=273.15*numpy.ones((md.mesh.numberofvertices,1)) ++pos=numpy.nonzero(md.mesh.vertexonsurface)[0] ++md.thermal.spctemperature[pos]=md.initialization.temperature[pos] ++md.materials.rheology_B=paterson(md.initialization.temperature) ++ ++#analytical results ++#melting heat = geothermal flux ++#Mb*L*rho=G => Mb=G/L*rho ++melting=md.basalforcings.geothermalflux/(md.materials.rho_ice*md.materials.latentheat)*md.constants.yts ++ ++#modeled results ++md.cluster=generic('name',oshostname(),'np',2) ++md=solve(md,ThermalSolutionEnum()) ++ ++#plot results ++comp_melting=md.results.ThermalSolution.BasalforcingsMeltingRate ++relative=numpy.abs((comp_melting-melting)/melting)*100. ++relative[numpy.nonzero(comp_melting==melting)[0]]=0. ++#plotmodel(md,'data',comp_melting,'title','Modeled melting','data',melting,'title','Analytical melting',... ++# 'data',comp_melting-melting,'title','Absolute error','data',relative,'title','Relative error [%]',... ++# 'layer#all',1,'caxis#2',[1.02964 1.02966]*10^-4,'FontSize#all',20,'figposition','mathieu') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('thermalmelting','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); ++# system(['mv thermalmelting.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); ++ ++#Fields and tolerances to track changes ++field_names =['BasalMelting'] ++field_tolerances=[1e-08] ++field_values =[comp_melting] + +Property changes on: ../trunk-jpl/test/NightlyRun/test1301.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt +=================================================================== +--- ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt (revision 14101) ++++ ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt (revision 14102) +@@ -10,3 +10,5 @@ + test417 needs Dakota + test418 needs Dakota + test420 needs Dakota ++test1401 roundoff error in metric causes different meshes from matlab ++test1402 roundoff error in metric causes different meshes from matlab +Index: ../trunk-jpl/test/NightlyRun/test1302.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1302.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1302.py (revision 14102) +@@ -0,0 +1,65 @@ ++import numpy ++import sys ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++This file can be run to check that the advection-diffusion is correctly modeled. ++There is u=v=0 and w=cst everywhere the only thermal boundary conditions are an imposed temperature ++at upper surface and an impose flux at its base. ++""" ++ ++printingflag=False ++ ++md=model() ++md=triangle(md,'../Exp/Square.exp',100000.) ++md=setmask(md,'','') ++md=parameterize(md,'../Par/SquareThermal.py') ++md.extrude(30,1.) #NB: the more one extrudes, the better (10-> relative~0.35%, 20->0.1%, 30->0.05%) ++md=setflowequation(md,'pattyn','all') ++ ++#Thermal boundary conditions ++pos1=numpy.nonzero(md.mesh.elementonbed)[0] ++md.thermal.spctemperature[md.mesh.elements[pos1,0:3]-1]=10. ++pos2=numpy.nonzero(md.mesh.elementonsurface)[0] ++md.thermal.spctemperature[md.mesh.elements[pos2,3:6]-1]=0. ++md.initialization.vz=0.1*numpy.ones((md.mesh.numberofvertices,1)) ++md.initialization.vel=numpy.sqrt( md.initialization.vx**2+ md.initialization.vy**2+ md.initialization.vz**2) ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1),int) ++ ++md.thermal.stabilization=2 ++#analytical results ++#d2T/dz2-w*rho_ice*c/k*dT/dz=0 T(surface)=0 T(bed)=10 => T=A exp(alpha z)+B ++alpha=0.1/md.constants.yts*md.materials.rho_ice*md.materials.heatcapacity/md.materials.thermalconductivity #alpha=w rho_ice c /k and w=0.1m/an ++A=10./(numpy.exp(alpha*(-1000.))-1.) #A=T(bed)/(exp(alpha*bed)-1) with bed=-1000 T(bed)=10 ++B=-A ++md.initialization.temperature=A*numpy.exp(alpha*md.mesh.z)+B ++ ++#modeled results ++md.cluster=generic('name',oshostname(),'np',2) ++md=solve(md,ThermalSolutionEnum()) ++ ++#plot results ++comp_temp=md.results.ThermalSolution.Temperature ++relative=numpy.abs((comp_temp-md.initialization.temperature)/md.initialization.temperature)*100. ++relative[numpy.nonzero(comp_temp==md.initialization.temperature)[0]]=0. ++#plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... ++# 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,... ++# 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... ++# 'figposition','mathieu','FontSize#all',20) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('thermaladvection','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); ++# system(['mv thermaladvection.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT ']); ++ ++#Fields and tolerances to track changes ++field_names =['AdvectionTemperature'] ++field_tolerances=[1e-13] ++field_values =[comp_temp] + +Property changes on: ../trunk-jpl/test/NightlyRun/test1302.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/NightlyRun/test1303.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1303.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1303.py (revision 14102) +@@ -0,0 +1,60 @@ ++import numpy ++import sys ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++This file can be run to check that the conduction is correctly modeled. ++There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature ++at the lower and upper surface. The result must be a linear temperature from the upper to the lower ++surface. if it is not the case, something is thermal modeling has been changed... ++""" ++ ++printingflag=False ++ ++md=model() ++md=triangle(md,'../Exp/Square.exp',100000.) ++md=setmask(md,'all','') ++md=parameterize(md,'../Par/SquareThermal.py') ++md.extrude(11,2.) ++md=setflowequation(md,'pattyn','all') ++ ++pos1=numpy.nonzero(md.mesh.elementonbed)[0] ++md.thermal.spctemperature[md.mesh.elements[pos1,0:3]-1]=10. ++pos2=numpy.nonzero(md.mesh.elementonsurface)[0] ++md.thermal.spctemperature[md.mesh.elements[pos2,3:6]-1]=0. ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1),int) ++ ++#analytical results ++#d2T/dz2=0 T(bed)=10 T(surface)=0 => T=0*(z-bed)/thickness+10*(surface-z)/thickness ++#each layer of the 3d mesh must have a constant value ++md.initialization.temperature=10.*(md.geometry.surface-md.mesh.z)/md.geometry.thickness ++ ++#modeled results ++md.cluster=generic('name',oshostname(),'np',2) ++md=solve(md,ThermalSolutionEnum()) ++ ++#plot results ++comp_temp=md.results.ThermalSolution.Temperature ++relative=numpy.abs((comp_temp-md.initialization.temperature)/md.initialization.temperature)*100. ++relative[numpy.nonzero(comp_temp==md.initialization.temperature)[0]]=0. ++#plotmodel(md,'data',comp_temp,'title','Modeled temperature [K]','data',md.initialization.temperature,'view',3,... ++# 'title','Analytical temperature [K]','view',3,'data',comp_temp-md.initialization.temperature,... ++# 'title','Absolute error [K]','view',3,'data',relative,'title','Relative error [%]','view',3,... ++# 'figposition','mathieu','FontSize#all',20) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('thermalconduction','png','margin','on','marginsize',25,'frame','off','resolution',0.7,'hardcopy','off'); ++# system(['mv thermalconduction.png ' ISSM_DIR '/website/doc_pdf/validation/Images/Thermal ']); ++ ++#Fields and tolerances to track changes ++field_names =['ConductionTemperature'] ++field_tolerances=[1e-13] ++field_values =[comp_temp] + +Property changes on: ../trunk-jpl/test/NightlyRun/test1303.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* Index: /issm/oecreview/Archive/14064-14311/ISSM-14102-14103.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14102-14103.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14102-14103.diff (revision 14312) @@ -0,0 +1,76 @@ +Index: ../trunk-jpl/src/m/classes/timestepping.py +=================================================================== +--- ../trunk-jpl/src/m/classes/timestepping.py (revision 14102) ++++ ../trunk-jpl/src/m/classes/timestepping.py (revision 14103) +@@ -15,11 +15,11 @@ + #properties + def __init__(self): + # {{{ Properties +- self.start_time = 0 +- self.final_time = 0 +- self.time_step = 0 ++ self.start_time = 0. ++ self.final_time = 0. ++ self.time_step = 0. + self.time_adapt = 0 +- self.cfl_coefficient = 0 ++ self.cfl_coefficient = 0. + + #set defaults + self.setdefaultparameters() +@@ -40,14 +40,14 @@ + # {{{setdefaultparameters + + #time between 2 time steps +- self.time_step=1/2 ++ self.time_step=1./2. + + #final time +- self.final_time=10*self.time_step ++ self.final_time=10.*self.time_step + + #time adaptation? + self.time_adapt=0 +- self.cfl_coefficient=.5 ++ self.cfl_coefficient=0.5 + + return self + #}}} +Index: ../trunk-jpl/src/m/classes/timestepping.m +=================================================================== +--- ../trunk-jpl/src/m/classes/timestepping.m (revision 14102) ++++ ../trunk-jpl/src/m/classes/timestepping.m (revision 14103) +@@ -5,11 +5,11 @@ + + classdef timestepping + properties (SetAccess=public) +- start_time = 0; +- final_time = 0; +- time_step = 0; ++ start_time = 0.; ++ final_time = 0.; ++ time_step = 0.; + time_adapt = 0; +- cfl_coefficient = 0; ++ cfl_coefficient = 0.; + end + methods + function obj = timestepping(varargin) % {{{ +@@ -23,14 +23,14 @@ + function obj = setdefaultparameters(obj) % {{{ + + %time between 2 time steps +- obj.time_step=1/2; ++ obj.time_step=1./2.; + + %final time +- obj.final_time=10*obj.time_step; ++ obj.final_time=10.*obj.time_step; + + %time adaptation? + obj.time_adapt=0; +- obj.cfl_coefficient=.5; ++ obj.cfl_coefficient=0.5; + end % }}} + function md = checkconsistency(obj,md,solution,analyses) % {{{ + Index: /issm/oecreview/Archive/14064-14311/ISSM-14103-14104.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14103-14104.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14103-14104.diff (revision 14312) @@ -0,0 +1,17 @@ +Index: ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py +=================================================================== +--- ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py (revision 14103) ++++ ../trunk-jpl/src/m/miscellaneous/MatlabFuncs.py (revision 14104) +@@ -96,3 +96,12 @@ + + return a + ++def heaviside(x): ++ import numpy ++ ++ y=numpy.zeros_like(x) ++ y[numpy.nonzero(x> 0.)]=1. ++ y[numpy.nonzero(x==0.)]=0.5 ++ ++ return y ++ Index: /issm/oecreview/Archive/14064-14311/ISSM-14104-14105.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14104-14105.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14104-14105.diff (revision 14312) @@ -0,0 +1,18 @@ +Index: ../trunk-jpl/src/m/solve/parseresultsfromdisk.py +=================================================================== +--- ../trunk-jpl/src/m/solve/parseresultsfromdisk.py (revision 14104) ++++ ../trunk-jpl/src/m/solve/parseresultsfromdisk.py (revision 14105) +@@ -42,10 +42,12 @@ + #Read fields until the end of the file. + result=ReadData(fid) + while result: +- if result['step'] > len(results): ++ if result['step'] > len(results): + for i in xrange(len(results),result['step']-1): + results.append(None) + results.append(resultsclass.results()) ++ elif results[result['step']-1] is None: ++ results[result['step']-1]=resultsclass.results() + #Get time and step + setattr(results[result['step']-1],'step',result['step']) + setattr(results[result['step']-1],'time',result['time']) Index: /issm/oecreview/Archive/14064-14311/ISSM-14105-14106.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14105-14106.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14105-14106.diff (revision 14312) @@ -0,0 +1,422 @@ +Index: ../trunk-jpl/test/Par/SquareEISMINT.py +=================================================================== +--- ../trunk-jpl/test/Par/SquareEISMINT.py (revision 0) ++++ ../trunk-jpl/test/Par/SquareEISMINT.py (revision 14106) +@@ -0,0 +1,49 @@ ++import numpy ++from SetMarineIceSheetBC import * ++ ++#Ok, start defining model parameters here ++ ++print " creating thickness" ++ymin=numpy.min(md.mesh.y) ++ymax=numpy.max(md.mesh.y) ++md.geometry.thickness=500.*numpy.ones((md.mesh.numberofvertices,1)) ++md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness ++md.geometry.surface=md.geometry.bed+md.geometry.thickness ++ ++print " creating drag" ++md.friction.coefficient=200.*numpy.ones((md.mesh.numberofvertices,1)) #q=1. ++#Take care of iceshelves: no basal drag ++pos=numpy.nonzero(md.mask.elementonfloatingice)[0] ++md.friction.coefficient[md.mesh.elements[pos,:]-1]=0. ++md.friction.p=numpy.ones((md.mesh.numberofelements,1)) ++md.friction.q=numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating initial values" ++md.initialization.temperature=(273.-20.)*numpy.ones((md.mesh.numberofvertices,1)) ++md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vy=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vz=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vel=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1)) ++ ++print " creating flow law parameter" ++md.materials.rheology_B=1.7687*10**8*numpy.ones((md.mesh.numberofvertices,1)) ++md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating surface mass balance" ++md.surfaceforcings.mass_balance=0.2*numpy.ones((md.mesh.numberofvertices,1)) #0m/a ++md.basalforcings.melting_rate=0.*numpy.ones((md.mesh.numberofvertices,1)) #0m/a ++ ++print " boundary conditions" ++md=SetMarineIceSheetBC(md,'../Exp/SquareFrontEISMINT.exp') ++ ++#Evolution of the ice shelf ++pos=numpy.nonzero(md.mesh.y==200000.) #nodes on the upper boundary condition ++md.balancethickness.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) ++md.balancethickness.spcthickness[pos]=500. ++md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) ++md.prognostic.spcthickness[pos]=500. ++md.prognostic.stabilization=0 #Better result with no artificial diffusivity ++md.thermal.stabilization=0 ++md.timestepping.final_time=500. ++md.timestepping.time_step=1 +Index: ../trunk-jpl/test/Par/RoundSheetEISMINT.par +=================================================================== +--- ../trunk-jpl/test/Par/RoundSheetEISMINT.par (revision 14105) ++++ ../trunk-jpl/test/Par/RoundSheetEISMINT.par (revision 14106) +@@ -1,35 +1,35 @@ + %Ok, start defining model parameters here + disp(' creating thickness'); +-md.geometry.thickness=10*ones(md.mesh.numberofvertices,1); ++md.geometry.thickness=10.*ones(md.mesh.numberofvertices,1); + md.geometry.bed=zeros(md.mesh.numberofvertices,1); + md.geometry.surface=md.geometry.bed+md.geometry.thickness; + + disp(' creating drag'); +-md.friction.coefficient=20*ones(md.mesh.numberofvertices,1); %q=1. %no drag is specified in the analytical solution ++md.friction.coefficient=20.*ones(md.mesh.numberofvertices,1); %q=1. no drag is specified in the analytical solution + md.friction.p=ones(md.mesh.numberofelements,1); + md.friction.q=ones(md.mesh.numberofelements,1); + + disp(' creating temperatures'); + tmin=238.15; %K +-st=1.67*10^-2/1000; %k/m; ++st=1.67*10^-2/1000.; %k/m + radius=sqrt((md.mesh.x).^2+(md.mesh.y).^2); + md.initialization.temperature=(tmin+st*radius); + md.basalforcings.geothermalflux=4.2*10^-2*ones(md.mesh.numberofvertices,1); + +-disp(' creating flow law paramter'); +-md.materials.rheology_B=6.81*10^(7)*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution +-md.materials.rheology_n=3*ones(md.mesh.numberofelements,1); ++disp(' creating flow law parameter'); ++md.materials.rheology_B=6.81*10^7*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution ++md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); + + disp(' creating surface mass balance'); + smb_max=0.5; %m/yr +-sb=10^-2/1000; %m/yr/m +-rel=450*1000; %m ++sb=10^-2/1000.; %m/yr/m ++rel=450.*1000.; %m + md.surfaceforcings.mass_balance=min(smb_max,sb*(rel-radius)); + + disp(' creating velocities'); + constant=0.3; +-md.inversion.vx_obs=constant/2*md.mesh.x.*(md.geometry.thickness).^-1; +-md.inversion.vy_obs=constant/2*md.mesh.y.*(md.geometry.thickness).^-1; ++md.inversion.vx_obs=constant/2.*md.mesh.x.*(md.geometry.thickness).^-1; ++md.inversion.vy_obs=constant/2.*md.mesh.y.*(md.geometry.thickness).^-1; + md.inversion.vel_obs=(sqrt((md.inversion.vx_obs).^2+(md.inversion.vy_obs).^2)); + md.initialization.vx=zeros(md.mesh.numberofvertices,1); + md.initialization.vy=zeros(md.mesh.numberofvertices,1); +@@ -37,23 +37,23 @@ + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); + + %Deal with boundary conditions: +-disp(' boundary conditions for diagnostic model: '); ++disp(' boundary conditions for diagnostic model:'); + md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp'); + +-radius=sqrt((md.mesh.x).*md.mesh.x+(md.mesh.y).*md.mesh.y); ++radius=sqrt((md.mesh.x).^2+(md.mesh.y).^2); + pos=find(radius==min(radius)); +-md.mesh.x(pos)=0; md.mesh.y(pos)=0; %the closest node to the center is changed to be exactly at the center ++md.mesh.x(pos)=0.; md.mesh.y(pos)=0.; %the closest node to the center is changed to be exactly at the center + +-md.diagnostic.spcvx(pos)=0; +-md.diagnostic.spcvy(pos)=0; +-md.diagnostic.spcvz(pos)=0; ++md.diagnostic.spcvx(pos)=0.; ++md.diagnostic.spcvy(pos)=0.; ++md.diagnostic.spcvz(pos)=0.; + + %parallel options +-md.timestepping.final_time=50000; ++md.timestepping.final_time=50000.; + + %Constants +-md.materials.rho_ice=910; ++md.materials.rho_ice=910.; + md.materials.thermalconductivity=2.1; + md.materials.latentheat=3.35*10^5; + md.materials.beta=8.66*10^-4/(md.materials.rho_ice*md.constants.g); %conversion from K/m to K/Pa +-md.constants.yts=31556926; ++md.constants.yts=31556926.; +Index: ../trunk-jpl/test/Par/RoundSheetEISMINT.py +=================================================================== +--- ../trunk-jpl/test/Par/RoundSheetEISMINT.py (revision 0) ++++ ../trunk-jpl/test/Par/RoundSheetEISMINT.py (revision 14106) +@@ -0,0 +1,63 @@ ++import numpy ++from SetMarineIceSheetBC import * ++ ++#Ok, start defining model parameters here ++print " creating thickness" ++md.geometry.thickness=10.*numpy.ones((md.mesh.numberofvertices,1)) ++md.geometry.bed=numpy.zeros((md.mesh.numberofvertices,1)) ++md.geometry.surface=md.geometry.bed+md.geometry.thickness ++ ++print " creating drag" ++md.friction.coefficient=20.*numpy.ones((md.mesh.numberofvertices,1)) #q=1. no drag is specified in the analytical solution ++md.friction.p=numpy.ones((md.mesh.numberofelements,1)) ++md.friction.q=numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating temperatures" ++tmin=238.15 #K ++st=1.67*10**-2/1000. #k/m ++radius=numpy.sqrt((md.mesh.x)**2+(md.mesh.y)**2).reshape(-1,1) ++md.initialization.temperature=tmin+st*radius ++md.basalforcings.geothermalflux=4.2*10**-2*numpy.ones((md.mesh.numberofvertices,1)) ++ ++print " creating flow law parameter" ++md.materials.rheology_B=6.81*10**7*numpy.ones((md.mesh.numberofvertices,1)) #to have the same B as the analytical solution ++md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating surface mass balance" ++smb_max=0.5 #m/yr ++sb=10**-2/1000. #m/yr/m ++rel=450.*1000. #m ++md.surfaceforcings.mass_balance=numpy.minimum(smb_max*numpy.ones_like(radius),sb*(rel-radius)) ++ ++print " creating velocities" ++constant=0.3 ++md.inversion.vx_obs=constant/2.*md.mesh.x.reshape(-1,1)*(md.geometry.thickness)**-1 ++md.inversion.vy_obs=constant/2.*md.mesh.y.reshape(-1,1)*(md.geometry.thickness)**-1 ++md.inversion.vel_obs=numpy.sqrt((md.inversion.vx_obs)**2+(md.inversion.vy_obs)**2) ++md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vy=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vz=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1)) ++ ++#Deal with boundary conditions: ++print " boundary conditions for diagnostic model:" ++md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp') ++ ++radius=numpy.sqrt((md.mesh.x)**2+(md.mesh.y)**2) ++pos=numpy.nonzero(radius==numpy.min(radius))[0] ++md.mesh.x[pos]=0. ++md.mesh.y[pos]=0. #the closest node to the center is changed to be exactly at the center ++ ++md.diagnostic.spcvx[pos]=0. ++md.diagnostic.spcvy[pos]=0. ++md.diagnostic.spcvz[pos]=0. ++ ++#parallel options ++md.timestepping.final_time=50000. ++ ++#Constants ++md.materials.rho_ice=910. ++md.materials.thermalconductivity=2.1 ++md.materials.latentheat=3.35*10**5 ++md.materials.beta=8.66*10**-4/(md.materials.rho_ice*md.constants.g) #conversion from K/m to K/Pa ++md.constants.yts=31556926. + +Property changes on: ../trunk-jpl/test/Par/RoundSheetEISMINT.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.par +=================================================================== +--- ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.par (revision 14105) ++++ ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.par (revision 14106) +@@ -1,54 +1,54 @@ + disp(' creating thickness'); + hmin=0.01; + hmax=2756.7; +-radius=(sqrt((md.mesh.x).^2+(md.mesh.y).^2)); ++radius=sqrt((md.mesh.x).^2+(md.mesh.y).^2); + radiusmax=max(radius); +-md.geometry.thickness=hmin*ones(size(md.mesh.x,1),1)+hmax*(4*((1/2)^(4/3)*ones(size(md.mesh.x,1),1)-((radius)./(2*radiusmax)).^(4/3))).^(3/8); +-md.geometry.bed=0*md.geometry.thickness; ++md.geometry.thickness=hmin*ones(size(md.mesh.x,1),1)+hmax*(4.*((1./2.)^(4./3.)*ones(size(md.mesh.x,1),1)-((radius)./(2.*radiusmax)).^(4./3.))).^(3./8.); ++md.geometry.bed=0.*md.geometry.thickness; + md.geometry.surface=md.geometry.bed+md.geometry.thickness; + + disp(' creating drag'); +-md.friction.coefficient=20*ones(md.mesh.numberofvertices,1); %q=1. %no drag is specified in the analytical solution ++md.friction.coefficient=20.*ones(md.mesh.numberofvertices,1); %q=1. no drag is specified in the analytical solution + %Take care of iceshelves: no basal drag + pos=find(md.mask.elementonfloatingice); +-md.friction.coefficient(md.mesh.elements(pos,:))=0; ++md.friction.coefficient(md.mesh.elements(pos,:))=0.; + md.friction.p=ones(md.mesh.numberofelements,1); + md.friction.q=ones(md.mesh.numberofelements,1); + + disp(' creating temperatures'); + tmin=238.15; %K +-st=1.67*10^-2/1000; %k/m; +-md.initialization.temperature=(tmin+st*radius); ++st=1.67*10^-2/1000.; %k/m ++md.initialization.temperature=tmin+st*radius; + md.basalforcings.geothermalflux=4.2*10^-2*ones(md.mesh.numberofvertices,1); + +-disp(' creating flow law paramter'); +-md.materials.rheology_B=6.81*10^(7)*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution +-md.materials.rheology_n=3*ones(md.mesh.numberofelements,1); ++disp(' creating flow law parameter'); ++md.materials.rheology_B=6.81*10^7*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution ++md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); + + disp(' creating surface mass balance'); + smb_max=0.5; %m/yr +-sb=10^-2/1000; %m/yr/m +-rel=450*1000; %m ++sb=10^-2/1000.; %m/yr/m ++rel=450.*1000.; %m + md.surfaceforcings.mass_balance=min(smb_max,sb*(rel-radius)); + + disp(' creating velocities'); + constant=0.3; +-md.inversion.vx_obs=constant/2*md.mesh.x.*(md.geometry.thickness).^-1; +-md.inversion.vy_obs=constant/2*md.mesh.y.*(md.geometry.thickness).^-1; +-md.inversion.vel_obs=(sqrt((md.inversion.vx_obs).^2+(md.inversion.vy_obs).^2)); ++md.inversion.vx_obs=constant/2.*md.mesh.x.*(md.geometry.thickness).^-1; ++md.inversion.vy_obs=constant/2.*md.mesh.y.*(md.geometry.thickness).^-1; ++md.inversion.vel_obs=sqrt((md.inversion.vx_obs).^2+(md.inversion.vy_obs).^2); + md.initialization.vx=zeros(md.mesh.numberofvertices,1); + md.initialization.vy=zeros(md.mesh.numberofvertices,1); + md.initialization.vz=zeros(md.mesh.numberofvertices,1); + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); + + %Deal with boundary conditions: +-disp(' boundary conditions for diagnostic model: '); ++disp(' boundary conditions for diagnostic model:'); + md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp'); + +-radius=sqrt((md.mesh.x).*md.mesh.x+(md.mesh.y).*md.mesh.y); ++radius=sqrt((md.mesh.x).^2+(md.mesh.y).^2); + pos=find(radius==min(radius)); +-md.mesh.x(pos)=0; md.mesh.y(pos)=0; %the closest node to the center is changed to be exactly at the center ++md.mesh.x(pos)=0.; md.mesh.y(pos)=0.; %the closest node to the center is changed to be exactly at the center + +-md.diagnostic.spcvx(pos)=0; +-md.diagnostic.spcvy(pos)=0; +-md.diagnostic.spcvz(pos)=0; ++md.diagnostic.spcvx(pos)=0.; ++md.diagnostic.spcvy(pos)=0.; ++md.diagnostic.spcvz(pos)=0.; +Index: ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.py +=================================================================== +--- ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.py (revision 0) ++++ ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.py (revision 14106) +@@ -0,0 +1,58 @@ ++import numpy ++from SetMarineIceSheetBC import * ++ ++print " creating thickness" ++hmin=0.01 ++hmax=2756.7 ++radius=numpy.sqrt((md.mesh.x)**2+(md.mesh.y)**2).reshape(-1,1) ++radiusmax=numpy.max(radius) ++md.geometry.thickness=hmin*numpy.ones((numpy.size(md.mesh.x),1))+hmax*(4.*((1./2.)**(4./3.)*numpy.ones((numpy.size(md.mesh.x),1))-((radius)/(2.*radiusmax))**(4./3.)))**(3./8.) ++md.geometry.bed=0.*md.geometry.thickness ++md.geometry.surface=md.geometry.bed+md.geometry.thickness ++ ++print " creating drag" ++md.friction.coefficient=20.*numpy.ones((md.mesh.numberofvertices,1)) #q=1. no drag is specified in the analytical solution ++#Take care of iceshelves: no basal drag ++pos=numpy.nonzero(md.mask.elementonfloatingice)[0] ++md.friction.coefficient[md.mesh.elements[pos,:]-1]=0. ++md.friction.p=numpy.ones((md.mesh.numberofelements,1)) ++md.friction.q=numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating temperatures" ++tmin=238.15 #K ++st=1.67*10**-2/1000. #k/m ++md.initialization.temperature=tmin+st*radius ++md.basalforcings.geothermalflux=4.2*10**-2*numpy.ones((md.mesh.numberofvertices,1)) ++ ++print " creating flow law parameter" ++md.materials.rheology_B=6.81*10**7*numpy.ones((md.mesh.numberofvertices,1)) #to have the same B as the analytical solution ++md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) ++ ++print " creating surface mass balance" ++smb_max=0.5 #m/yr ++sb=10**-2/1000. #m/yr/m ++rel=450.*1000. #m ++md.surfaceforcings.mass_balance=numpy.minimum(smb_max*numpy.ones_like(radius),sb*(rel-radius)) ++ ++print " creating velocities" ++constant=0.3 ++md.inversion.vx_obs=constant/2.*md.mesh.x.reshape(-1,1)*(md.geometry.thickness)**-1 ++md.inversion.vy_obs=constant/2.*md.mesh.y.reshape(-1,1)*(md.geometry.thickness)**-1 ++md.inversion.vel_obs=numpy.sqrt((md.inversion.vx_obs)**2+(md.inversion.vy_obs)**2) ++md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vy=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.vz=numpy.zeros((md.mesh.numberofvertices,1)) ++md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices,1)) ++ ++#Deal with boundary conditions: ++print " boundary conditions for diagnostic model:" ++md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp') ++ ++radius=numpy.sqrt((md.mesh.x)**2+(md.mesh.y)**2) ++pos=numpy.nonzero(radius==numpy.min(radius))[0] ++md.mesh.x[pos]=0. ++md.mesh.y[pos]=0. #the closest node to the center is changed to be exactly at the center ++ ++md.diagnostic.spcvx[pos]=0. ++md.diagnostic.spcvy[pos]=0. ++md.diagnostic.spcvz[pos]=0. + +Property changes on: ../trunk-jpl/test/Par/RoundSheetStaticEISMINT.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/Par/SquareEISMINT.par +=================================================================== +--- ../trunk-jpl/test/Par/SquareEISMINT.par (revision 14105) ++++ ../trunk-jpl/test/Par/SquareEISMINT.par (revision 14106) +@@ -3,44 +3,44 @@ + disp(' creating thickness'); + ymin=min(md.mesh.y); + ymax=max(md.mesh.y); +-md.geometry.thickness=500*ones(md.mesh.numberofvertices,1); ++md.geometry.thickness=500.*ones(md.mesh.numberofvertices,1); + md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness; + md.geometry.surface=md.geometry.bed+md.geometry.thickness; + + disp(' creating drag'); +-md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1. ++md.friction.coefficient=200.*ones(md.mesh.numberofvertices,1); %q=1. + %Take care of iceshelves: no basal drag + pos=find(md.mask.elementonfloatingice); +-md.friction.coefficient(md.mesh.elements(pos,:))=0; ++md.friction.coefficient(md.mesh.elements(pos,:))=0.; + md.friction.p=ones(md.mesh.numberofelements,1); + md.friction.q=ones(md.mesh.numberofelements,1); + + disp(' creating initial values'); +-md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1); ++md.initialization.temperature=(273.-20.)*ones(md.mesh.numberofvertices,1); + md.initialization.vx=zeros(md.mesh.numberofvertices,1); + md.initialization.vy=zeros(md.mesh.numberofvertices,1); + md.initialization.vz=zeros(md.mesh.numberofvertices,1); + md.initialization.vel=zeros(md.mesh.numberofvertices,1); + md.initialization.pressure=zeros(md.mesh.numberofvertices,1); + +-disp(' creating flow law paramter'); ++disp(' creating flow law parameter'); + md.materials.rheology_B=1.7687*10^8*ones(md.mesh.numberofvertices,1); +-md.materials.rheology_n=3*ones(md.mesh.numberofelements,1); ++md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); + + disp(' creating surface mass balance'); + md.surfaceforcings.mass_balance=0.2*ones(md.mesh.numberofvertices,1); %0m/a +-md.basalforcings.melting_rate=0*ones(md.mesh.numberofvertices,1); %0m/a ++md.basalforcings.melting_rate=0.*ones(md.mesh.numberofvertices,1); %0m/a + +-disp(' boundary conditions '); ++disp(' boundary conditions'); + md=SetMarineIceSheetBC(md,'../Exp/SquareFrontEISMINT.exp'); + + %Evolution of the ice shelf +-pos=find(md.mesh.y==200000); %nodes on the upper boundary condition ++pos=find(md.mesh.y==200000.); %nodes on the upper boundary condition + md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +-md.balancethickness.spcthickness(pos)=500; ++md.balancethickness.spcthickness(pos)=500.; + md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +-md.prognostic.spcthickness(pos)=500; ++md.prognostic.spcthickness(pos)=500.; + md.prognostic.stabilization=0; %Better result with no artificial diffusivity +-md.thermal.stabilization=0; +-md.timestepping.final_time=500; ++md.thermal.stabilization=0; ++md.timestepping.final_time=500.; + md.timestepping.time_step=1; Index: /issm/oecreview/Archive/14064-14311/ISSM-14106-14107.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14106-14107.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14106-14107.diff (revision 14312) @@ -0,0 +1,574 @@ +Index: ../trunk-jpl/test/NightlyRun/test1202.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1202.m (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/test1202.m (revision 14107) +@@ -18,7 +18,7 @@ + + plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,60,100,120,140,160,180,-20,-40,-60,-80,-100,-120,-140,-160,-180}, ... + 'contourcolor','k') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eismintdiag1vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eismintdiag1vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); +@@ -26,7 +26,7 @@ + + plotmodel(md,'data',vy,'contourlevels',{-100,-200,-300,-400,-500,-600,-700,-800,-900,-1000},... + 'contourcolor','k') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eismintdiag1vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eismintdiag1vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); +Index: ../trunk-jpl/test/NightlyRun/test1203.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1203.m (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/test1203.m (revision 14107) +@@ -1,7 +1,7 @@ + %Test on the diagnostic model and the prognostic in 2d + printingflag=false; + +-%test 5 and 6 : ++%test 5 and 6: + md=model(); + md=triangle(md,'../Exp/SquareEISMINT.exp',5100.); %test3 + md=setmask(md,'all',''); +@@ -10,7 +10,7 @@ + + %Impose a non zero velocity on the upper boundary condition (y=max(y)) + pos=find(md.mesh.y==max(md.mesh.y)); +-md.diagnostic.spcvy(pos)=400*(((md.mesh.x(pos)-100000)/25000).^2-ones(size(pos,1),1)).*heaviside((1+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000)/25000).^2); ++md.diagnostic.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); + + %Compute solution for MacAyeal's model + md.cluster=generic('name',oshostname(),'np',8); +@@ -22,14 +22,14 @@ + %plot results + plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,80,100,-20,-40,-60,-80,-100},... + 'contourcolor','k') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eismintdiag2vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eismintdiag2vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); + end + plotmodel(md,'data',vy,'contourlevels',{-100,-200,-300,-400,-500,-600,-700,-800,-900,-1000},... + 'contourcolor','k') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eismintdiag2vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eismintdiag2vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); +Index: ../trunk-jpl/test/NightlyRun/test1201.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1201.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1201.py (revision 14107) +@@ -0,0 +1,78 @@ ++import numpy ++from model import * ++from bamg import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++This test is a test from the EISMINT for Ice shelves Vincent Rommelaere 1996 ++""" ++ ++printingflag=False ++ ++results=[] ++ ++for stabilization in xrange(1,4): ++ #The goal is to test the prognostic model ++ md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.) ++ md=setmask(md,'all','') ++ md=parameterize(md,'../Par/SquareEISMINT.py') ++ md.surfaceforcings.mass_balance[:]=0. ++ md=setflowequation(md,'macayeal','all') ++ md.cluster=generic('name',oshostname(),'np',8) ++ ++ print " initial velocity" ++ md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) ++ md.initialization.vy=-400.*numpy.ones((md.mesh.numberofvertices,1)) ++ ++ #Stabilization ++ if stabilization==2: ++ md.prognostic.stabilization=0 ++ else: ++ md.prognostic.stabilization=stabilization ++ ++ #spc thickness ++ pos=numpy.nonzero(md.mesh.y>199999.9)[0] ++ times=numpy.arange(0,501) ++ md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices+1,numpy.size(times))) ++ md.prognostic.spcthickness[-1,:]=times ++ md.prognostic.spcthickness[pos,:]=numpy.tile(500.+100.*numpy.sin(2.*numpy.pi*times/200.),(numpy.size(pos),1)) ++ if stabilization==3: ++ pos=numpy.nonzero(numpy.isnan(md.prognostic.spcthickness)) ++ md.prognostic.spcthickness[pos]=500. #No NaN for DG ++ ++ #solve ++ md.transient.isdiagnostic=False ++ md.settings.output_frequency=500 #keep only last step ++ md.verbose=verbose() ++ md=solve(md,TransientSolutionEnum()) ++ results.append(md.results.TransientSolution[-1].Thickness) ++ ++#plot results ++#[elements,x,y,z,s,h1]=SectionValues(md,results[0],'../Exp/CrossLineEISMINT.exp',100.); ++#[elements,x,y,z,s,h2]=SectionValues(md,results[1],'../Exp/CrossLineEISMINT.exp',100.); ++#[elements,x,y,z,s,h3]=SectionValues(md,results[2],'../Exp/CrossLineEISMINT.exp',100.); ++#[elements,x,y,z,s,hth]=SectionValues(md, 500+100*sin(2*pi/200*(500-md.mesh.y/400)),'../Exp/CrossLineEISMINT.exp',100.); ++#plot(s,h1,'r',s,h2,'b',s,h3,'g',s,hth,'k') ++#legend('Art. diff.','No Art. diff.','D.G.','Theoretical') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# export_fig([issmdir() '/website/doc_pdf/validation/Images/EISMINT/IceShelf/eismintmasscthickness.pdf']); ++ ++#Fields and tolerances to track changes ++field_names =[ \ ++ 'ThicknessArtDiff','ThicknessNoArtDiff','ThicknessDG' \ ++] ++field_tolerances=[\ ++ 1e-13, 1e-13, 1e-13\ ++] ++field_values=[ ++ results[0], \ ++ results[1], \ ++ results[2], \ ++] +Index: ../trunk-jpl/test/NightlyRun/test1204.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1204.m (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/test1204.m (revision 14107) +@@ -10,7 +10,7 @@ + + %Impose a non zero velocity on the upper boundary condition (y=max(y)) + pos=find(md.mesh.y==max(md.mesh.y)); +-md.diagnostic.spcvy(pos)=400*(((md.mesh.x(pos)-100000)/25000).^2-ones(size(pos,1),1)).*heaviside((1+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000)/25000).^2); ++md.diagnostic.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); + + %Compute solution for MacAyeal's model + md.cluster=generic('name',oshostname(),'np',8); +@@ -20,27 +20,27 @@ + md.initialization.vx=(md.results.DiagnosticSolution.Vx); + md.initialization.vy=(md.results.DiagnosticSolution.Vy); + +-md.timestepping.time_step=1; +-md.timestepping.final_time=5000; ++md.timestepping.time_step=1.; ++md.timestepping.final_time=5000.; + md.prognostic.stabilization=1; + md=solve(md,TransientSolutionEnum()); + + plotmodel(md,'data',(md.results.TransientSolution(end).Vx)) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eisminttrans2vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eisminttrans2vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); + end + + plotmodel(md,'data',(md.results.TransientSolution(end).Vy)) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eisminttrans2vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eisminttrans2vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); + end + + plotmodel(md,'data',(md.results.TransientSolution(end).Thickness)) +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + printmodel('eisminttrans2thickness','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); + system(['mv eisminttrans2thickness.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); +Index: ../trunk-jpl/test/NightlyRun/test1202.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1202.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1202.py (revision 14107) +@@ -0,0 +1,54 @@ ++import numpy ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++Test on the diagnostic model and the prognostic in 2d ++""" ++ ++printingflag=False ++ ++#tests 3 and 4: using Glen's flow law ++md=model() ++md=triangle(md,'../Exp/SquareEISMINT.exp',3550.) ++md=setmask(md,'all','') ++md=parameterize(md,'../Par/SquareEISMINT.py') ++md=setflowequation(md,'macayeal','all') #MacAyeal's model and 2d ++ ++#Compute solution for MacAyeal's model ++md.cluster=generic('name',oshostname(),'np',8) ++md=solve(md,DiagnosticSolutionEnum()) ++ ++#plot results ++vx=md.results.DiagnosticSolution.Vx ++vy=md.results.DiagnosticSolution.Vy ++ ++#plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,60,100,120,140,160,180,-20,-40,-60,-80,-100,-120,-140,-160,-180}, ... ++# 'contourcolor','k') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eismintdiag1vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eismintdiag1vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#plotmodel(md,'data',vy,'contourlevels',{-100,-200,-300,-400,-500,-600,-700,-800,-900,-1000},... ++# 'contourcolor','k') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eismintdiag1vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eismintdiag1vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#Fields and tolerances to track changes ++field_names =['Vx','Vy'] ++field_tolerances=[1e-13,1e-13] ++field_values=[\ ++ vx, \ ++ vy, \ ++ ] +Index: ../trunk-jpl/test/NightlyRun/test1208.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1208.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1208.py (revision 14107) +@@ -0,0 +1,58 @@ ++import numpy ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++EISMINT benchmark experiment A ++""" ++ ++numlayers=8 ++resolution=50000. ++ ++#To begin with the numerical model ++md=triangle(model(),'../Exp/SquareEISMINT750000.exp',resolution) ++md=setmask(md,'','') ++md=parameterize(md,'../Par/RoundSheetEISMINT.py') ++ ++#We extrude the model to have a 3d model ++md.extrude(numlayers,1.) ++md=setflowequation(md,'hutter','all') ++ ++#Spc the nodes on the bed ++pos=numpy.nonzero(md.mesh.vertexonbed) ++md.diagnostic.spcvx[pos]=0. ++md.diagnostic.spcvy[pos]=0. ++md.diagnostic.spcvz[pos]=0. ++ ++#Adapt the time steps to the resolution ++md.timestepping.time_step=15. ++md.settings.output_frequency=500 ++md.timestepping.final_time=30000. ++md.prognostic.stabilization=1 ++md.thermal.stabilization=1 ++ ++#Now we can solve the problem ++md.cluster=generic('name',oshostname(),'np',8) ++md=solve(md,TransientSolutionEnum()) ++ ++#Fields and tolerances to track changes ++field_names =['Vx','Vy','Vz','Vel','Pressure','Thickness','Bed','Surface','Temperature','BasalforcingsMeltingRate'] ++field_tolerances=[1e-08,1e-08,1e-07,1e-08,1e-08,1e-08,1e-08,1e-08,1e-07,1e-07] ++field_values=[\ ++ md.results.TransientSolution[-1].Vx,\ ++ md.results.TransientSolution[-1].Vy,\ ++ md.results.TransientSolution[-1].Vz,\ ++ md.results.TransientSolution[-1].Vel,\ ++ md.results.TransientSolution[-1].Pressure,\ ++ md.results.TransientSolution[-1].Thickness,\ ++ md.results.TransientSolution[-1].Bed,\ ++ md.results.TransientSolution[-1].Surface,\ ++ md.results.TransientSolution[-1].Temperature,\ ++ md.results.TransientSolution[-1].BasalforcingsMeltingRate,\ ++ ] + +Property changes on: ../trunk-jpl/test/NightlyRun/test1208.py +___________________________________________________________________ +Added: svn:executable +## -0,0 +1 ## ++* +Index: ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt +=================================================================== +--- ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/python_skipped_tests.txt (revision 14107) +@@ -10,5 +10,16 @@ + test417 needs Dakota + test418 needs Dakota + test420 needs Dakota +-test1401 roundoff error in metric causes different meshes from matlab +-test1402 roundoff error in metric causes different meshes from matlab ++ ++test1401,test1402 ++Roundoff error in ComputeHessian and ComputeMetric causes different meshes ++from matlab, specifically in the handling of 0/0=nan, eps/0=inf, etc. Since ++the mesh is of a different size, NR fails. (Note Matlab test1402 currently ++fails.) ++ ++test1205,test1206,test1207 ++The expression for the thickness in the RoundSheetStaticEISMINT.par/py files ++includes an expression (1/2)^(4/3)-(r/(2*rmax))^(4/3). For r close to rmax, ++the outer circumference, this equals roundoff zero, but differences ++propagate into the sixth digit of the thickness, which is enough to fail NR. ++ +Index: ../trunk-jpl/test/NightlyRun/test1203.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1203.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1203.py (revision 14107) +@@ -0,0 +1,58 @@ ++import numpy ++import sys ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++Test on the diagnostic model and the prognostic in 2d ++""" ++ ++printingflag=False ++ ++#test 5 and 6: ++md=model() ++md=triangle(md,'../Exp/SquareEISMINT.exp',5100.) #test3 ++md=setmask(md,'all','') ++md=parameterize(md,'../Par/SquareEISMINT.py') ++md=setflowequation(md,'macayeal','all') #MacAyeal's model and 2d ++ ++#Impose a non zero velocity on the upper boundary condition (y=max(y)) ++pos=numpy.nonzero(md.mesh.y==numpy.max(md.mesh.y)) ++md.diagnostic.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) ++ ++#Compute solution for MacAyeal's model ++md.cluster=generic('name',oshostname(),'np',8) ++md=solve(md,DiagnosticSolutionEnum()) ++ ++vx=md.results.DiagnosticSolution.Vx ++vy=md.results.DiagnosticSolution.Vy ++ ++#plot results ++#plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,80,100,-20,-40,-60,-80,-100},... ++# 'contourcolor','k') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eismintdiag2vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eismintdiag2vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++#plotmodel(md,'data',vy,'contourlevels',{-100,-200,-300,-400,-500,-600,-700,-800,-900,-1000},... ++# 'contourcolor','k') ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eismintdiag2vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eismintdiag2vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#Fields and tolerances to track changes ++field_names =['Vx','Vy'] ++field_tolerances=[1e-13,1e-13] ++field_values=[\ ++ vx, \ ++ vy, \ ++ ] +Index: ../trunk-jpl/test/NightlyRun/test1208.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1208.m (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/test1208.m (revision 14107) +@@ -1,6 +1,6 @@ + %EISMINT benchmark experiment A + numlayers=8; +-resolution=50000; ++resolution=50000.; + + %To begin with the numerical model + md=triangle(model(),'../Exp/SquareEISMINT750000.exp',resolution); +@@ -13,14 +13,14 @@ + + %Spc the nodes on the bed + pos=find(md.mesh.vertexonbed); +-md.diagnostic.spcvx(pos)=0; +-md.diagnostic.spcvy(pos)=0; +-md.diagnostic.spcvz(pos)=0; ++md.diagnostic.spcvx(pos)=0.; ++md.diagnostic.spcvy(pos)=0.; ++md.diagnostic.spcvz(pos)=0.; + + %Adapt the time steps to the resolution +-md.timestepping.time_step=15; ++md.timestepping.time_step=15.; + md.settings.output_frequency=500; +-md.timestepping.final_time=30000; ++md.timestepping.final_time=30000.; + md.prognostic.stabilization=1; + md.thermal.stabilization=1; + +Index: ../trunk-jpl/test/NightlyRun/test1204.py +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1204.py (revision 0) ++++ ../trunk-jpl/test/NightlyRun/test1204.py (revision 14107) +@@ -0,0 +1,70 @@ ++import numpy ++import sys ++from model import * ++from triangle import * ++from setmask import * ++from parameterize import * ++from setflowequation import * ++from EnumDefinitions import * ++from solve import * ++from MatlabFuncs import * ++ ++""" ++Test on the diagnostic model and the prognostic in 2d ++""" ++ ++printingflag=False ++ ++#tests 3 and 4: using Glen's flow law ++md=model() ++md=triangle(md,'../Exp/SquareEISMINT.exp',3550.) ++md=setmask(md,'all','') ++md=parameterize(md,'../Par/SquareEISMINT.py') ++md=setflowequation(md,'macayeal','all') #MacAyeal's model and 2d ++ ++#Impose a non zero velocity on the upper boundary condition (y=max(y)) ++pos=numpy.nonzero(md.mesh.y==max(md.mesh.y)) ++md.diagnostic.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) ++ ++#Compute solution for MacAyeal's model ++md.cluster=generic('name',oshostname(),'np',8) ++md=solve(md,DiagnosticSolutionEnum()) ++ ++#plot results ++md.initialization.vx=md.results.DiagnosticSolution.Vx ++md.initialization.vy=md.results.DiagnosticSolution.Vy ++ ++md.timestepping.time_step=1. ++md.timestepping.final_time=5000. ++md.prognostic.stabilization=1 ++md=solve(md,TransientSolutionEnum()) ++ ++#plotmodel(md,'data',(md.results.TransientSolution(end).Vx)) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eisminttrans2vx','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eisminttrans2vx.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#plotmodel(md,'data',(md.results.TransientSolution(end).Vy)) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eisminttrans2vy','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eisminttrans2vy.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#plotmodel(md,'data',(md.results.TransientSolution(end).Thickness)) ++if printingflag: ++ pass ++# set(gcf,'Color','w') ++# printmodel('eisminttrans2thickness','png','margin','on','marginsize',25,'frame','off','resolution',2,'hardcopy','off'); ++# system(['mv eisminttrans2thickness.png ' ISSM_DIR '/website/doc_pdf/validation/Images/EISMINT/IceShelf ']); ++ ++#Fields and tolerances to track changes ++field_names =['Vx','Vy','Thickness'] ++field_tolerances=[1e-13,1e-13,1e-13] ++field_values=[\ ++ md.results.TransientSolution[-1].Vx, \ ++ md.results.TransientSolution[-1].Vy, \ ++ md.results.TransientSolution[-1].Thickness, \ ++ ] +Index: ../trunk-jpl/test/NightlyRun/test1201.m +=================================================================== +--- ../trunk-jpl/test/NightlyRun/test1201.m (revision 14106) ++++ ../trunk-jpl/test/NightlyRun/test1201.m (revision 14107) +@@ -5,16 +5,16 @@ + + for stabilization=1:3; + %The goal is to test the prognostic model +- md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000); ++ md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.); + md=setmask(md,'all',''); + md=parameterize(md,'../Par/SquareEISMINT.par'); +- md.surfaceforcings.mass_balance(:)=0; ++ md.surfaceforcings.mass_balance(:)=0.; + md=setflowequation(md,'macayeal','all'); + md.cluster=generic('name',oshostname(),'np',8); + + disp(' initial velocity'); + md.initialization.vx=zeros(md.mesh.numberofvertices,1); +- md.initialization.vy=-400*ones(md.mesh.numberofvertices,1); ++ md.initialization.vy=-400.*ones(md.mesh.numberofvertices,1); + + %Stabilization + if stabilization==2, +@@ -28,9 +28,9 @@ + times=0:1:500; + md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times)); + md.prognostic.spcthickness(end,:)=times; +- md.prognostic.spcthickness(pos,:)=repmat(500+100*sin(2*pi*times/200),length(pos),1); ++ md.prognostic.spcthickness(pos,:)=repmat(500.+100.*sin(2.*pi*times/200.),length(pos),1); + if stabilization==3, +- pos=find(isnan(md.prognostic.spcthickness)); md.prognostic.spcthickness(pos)=500; %No NaN for DG ++ pos=find(isnan(md.prognostic.spcthickness)); md.prognostic.spcthickness(pos)=500.; %No NaN for DG + end + + %solve +@@ -42,20 +42,20 @@ + end + + %plot results +-[elements,x,y,z,s,h1]=SectionValues(md,results{1},'../Exp/CrossLineEISMINT.exp',100); +-[elements,x,y,z,s,h2]=SectionValues(md,results{2},'../Exp/CrossLineEISMINT.exp',100); +-[elements,x,y,z,s,h3]=SectionValues(md,results{3},'../Exp/CrossLineEISMINT.exp',100); +-[elements,x,y,z,s,hth]=SectionValues(md, 500+100*sin(2*pi/200*(500-md.mesh.y/400)),'../Exp/CrossLineEISMINT.exp',100); ++[elements,x,y,z,s,h1]=SectionValues(md,results{1},'../Exp/CrossLineEISMINT.exp',100.); ++[elements,x,y,z,s,h2]=SectionValues(md,results{2},'../Exp/CrossLineEISMINT.exp',100.); ++[elements,x,y,z,s,h3]=SectionValues(md,results{3},'../Exp/CrossLineEISMINT.exp',100.); ++[elements,x,y,z,s,hth]=SectionValues(md, 500+100*sin(2*pi/200*(500-md.mesh.y/400)),'../Exp/CrossLineEISMINT.exp',100.); + plot(s,h1,'r',s,h2,'b',s,h3,'g',s,hth,'k') + legend('Art. diff.','No Art. diff.','D.G.','Theoretical') +-if printingflag, ++if printingflag, + set(gcf,'Color','w') + export_fig([issmdir() '/website/doc_pdf/validation/Images/EISMINT/IceShelf/eismintmasscthickness.pdf']); + end + + %Fields and tolerances to track changes + field_names ={ ... +- 'ThicknessArtDigg','ThicknessNoArtDiff','ThicknessDG' ... ++ 'ThicknessArtDiff','ThicknessNoArtDiff','ThicknessDG' ... + }; + field_tolerances={... + 1e-13, 1e-13, 1e-13... Index: /issm/oecreview/Archive/14064-14311/ISSM-14107-14108.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14107-14108.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14107-14108.diff (revision 14312) @@ -0,0 +1,116 @@ +Index: ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/colormap.c +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/colormap.c (revision 0) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/colormap.c (revision 14108) +@@ -0,0 +1,83 @@ ++int nrows=64; ++double hsv[nrows,3]={ ++1.0000 0 0 ++ 1.0000 0.0938 0 ++ 1.0000 0.1875 0 ++ 1.0000 0.2812 0 ++ 1.0000 0.3750 0 ++ 1.0000 0.4688 0 ++ 1.0000 0.5625 0 ++ 1.0000 0.6562 0 ++ 1.0000 0.7500 0 ++ 1.0000 0.8438 0 ++ 1.0000 0.9375 0 ++ 0.9688 1.0000 0 ++ 0.8750 1.0000 0 ++ 0.7812 1.0000 0 ++ 0.6875 1.0000 0 ++ 0.5938 1.0000 0 ++ 0.5000 1.0000 0 ++ 0.4062 1.0000 0 ++ 0.3125 1.0000 0 ++ 0.2188 1.0000 0 ++ 0.1250 1.0000 0 ++ 0.0312 1.0000 0 ++ 0 1.0000 0.0625 ++ 0 1.0000 0.1562 ++ 0 1.0000 0.2500 ++ 0 1.0000 0.3438 ++ 0 1.0000 0.4375 ++ 0 1.0000 0.5312 ++ 0 1.0000 0.6250 ++ 0 1.0000 0.7188 ++ 0 1.0000 0.8125 ++ 0 1.0000 0.9062 ++ 0 1.0000 1.0000 ++ 0 0.9062 1.0000 ++ 0 0.8125 1.0000 ++ 0 0.7188 1.0000 ++ 0 0.6250 1.0000 ++ 0 0.5312 1.0000 ++ 0 0.4375 1.0000 ++ 0 0.3438 1.0000 ++ 0 0.2500 1.0000 ++ 0 0.1562 1.0000 ++ 0 0.0625 1.0000 ++ 0.0312 0 1.0000 ++ 0.1250 0 1.0000 ++ 0.2188 0 1.0000 ++ 0.3125 0 1.0000 ++ 0.4062 0 1.0000 ++ 0.5000 0 1.0000 ++ 0.5938 0 1.0000 ++ 0.6875 0 1.0000 ++ 0.7812 0 1.0000 ++ 0.8750 0 1.0000 ++ 0.9688 0 1.0000 ++ 1.0000 0 0.9375 ++ 1.0000 0 0.8438 ++ 1.0000 0 0.7500 ++ 1.0000 0 0.6562 ++ 1.0000 0 0.5625 ++ 1.0000 0 0.4688 ++ 1.0000 0 0.3750 ++ 1.0000 0 0.2812 ++ 1.0000 0 0.1875 ++ 1.0000 0 0.0938 ++} ++ ++ ++ ++value v=5*10^-5; // (m/s) ++value vmin,vmax; ++ ++ ++ ++double alpha=(vmax-alpha)/(vmax-vmin); ++int i=(int)(alpha*nrows); ++ ++double r,g,b; ++ ++r=hsv[i,1]; ++g=hsv[i,2]; ++b=hsv[i,3]; +Index: ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/list_of_colormaps +=================================================================== +--- ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/list_of_colormaps (revision 0) ++++ ../trunk-jpl/src/android/ISSM_Visual/src/gov/nasa/jpl/issm/visual/colormap/list_of_colormaps (revision 14108) +@@ -0,0 +1,23 @@ ++hsv - Hue-saturation-value color map. ++hot - Black-red-yellow-white color map. ++gray - Linear gray-scale color map. ++bone - Gray-scale with tinge of blue color map. ++copper - Linear copper-tone color map. ++pink - Pastel shades of pink color map. ++white - All white color map. ++flag - Alternating red, white, blue, and black color map. ++lines - Color map with the line colors. ++colorcube - Enhanced color-cube color map. ++vga - Windows colormap for 16 colors. ++jet - Variant of HSV. ++prism - Prism color map. ++cool - Shades of cyan and magenta color map. ++autumn - Shades of red and yellow color map. ++spring - Shades of magenta and yellow color map. ++winter - Shades of blue and green color map. ++summer ++ ++ ++ ++a=colormap('hsv'); ++a Index: /issm/oecreview/Archive/14064-14311/ISSM-14108-14109.diff =================================================================== --- /issm/oecreview/Archive/14064-14311/ISSM-14108-14109.diff (revision 14312) +++ /issm/oecreview/Archive/14064-14311/ISSM-14108-14109.diff (revision 14312) @@ -0,0 +1,773 @@ +Index: ../trunk-jpl/src/android/ISSM/jni/Main.cpp +=================================================================== +--- ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/jni/Main.cpp (revision 14109) +@@ -78,7 +78,6 @@ + /*log:*/ + __android_log_print(ANDROID_LOG_INFO, "Native","Solving "); + +- /*fill out the first two slots, extract the same way in java using get(int position)*/ + jdouble *dBuf = (jdouble *)env->GetDirectBufferAddress(buf); + + /*pass bBuff to fem model to allocate data. In the future: fm -> Solve(dBuf, alpha)*/ +@@ -138,13 +137,13 @@ + } + } + +- /*for(i=0;i<148;i++){ ++ for(i=0;i<148;i++){ + __android_log_print(ANDROID_LOG_INFO, "Native","%g %g %g | %g %g %g | %g %g %g | %g %g %g\n", + dBuf[12*i+0],dBuf[12*i+1],dBuf[12*i+2], + dBuf[12*i+3],dBuf[12*i+4],dBuf[12*i+5], + dBuf[12*i+6],dBuf[12*i+7],dBuf[12*i+8], + dBuf[12*i+9],dBuf[12*i+10],dBuf[12*i+11]); +- }*/ ++ } + + /*delete temporary data:*/ + delete patch; +Index: ../trunk-jpl/src/android/ISSM/project.properties +=================================================================== +--- ../trunk-jpl/src/android/ISSM/project.properties (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/project.properties (revision 14109) +@@ -11,4 +11,4 @@ + #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + + # Project target. +-target=android-14 ++target=android-15 +Index: ../trunk-jpl/src/android/ISSM/AndroidManifest.xml +=================================================================== +--- ../trunk-jpl/src/android/ISSM/AndroidManifest.xml (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/AndroidManifest.xml (revision 14109) +@@ -1,8 +1,8 @@ + +- ++ android:versionName="1.0" ++ android:installLocation="preferExternal" > + +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLRenderer.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLRenderer.java (revision 0) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLRenderer.java (revision 14109) +@@ -0,0 +1,295 @@ ++/* ++ * Copyright (C) 2012 The Android Open Source Project ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package com.example.issm; ++import java.nio.ByteBuffer; ++import java.nio.ByteOrder; ++import java.nio.FloatBuffer; ++ ++import javax.microedition.khronos.egl.EGLConfig; ++import javax.microedition.khronos.opengles.GL10; ++ ++import android.opengl.GLES20; ++import android.opengl.GLSurfaceView; ++import android.opengl.Matrix; ++ ++public class MyGLRenderer implements GLSurfaceView.Renderer ++{ ++ public volatile float mAngle; ++ ++ /** ++ * Store the model matrix. This matrix is used to move models from object space (where each model can be thought ++ * of being located at the center of the universe) to world space. ++ */ ++ private float[][] mModelMatrix; ++ ++ /** ++ * Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space; ++ * it positions things relative to our eye. ++ */ ++ private float[][] mViewMatrix; ++ ++ /** Store the projection matrix. This is used to project the scene onto a 2D viewport. */ ++ private float[][] mProjectionMatrix; ++ ++ /** Allocate storage for the final combined matrix. This will be passed into the shader program. */ ++ private float[][] mMVPMatrix; ++ ++ /** This will be used to pass in the transformation matrix. */ ++ private int mMatrixHandle; ++ ++ private FloatBuffer[] triangleVert; ++ ++ private float[][] triangleData2DArr; ++ ++ private int mPositionHandle; ++ ++ private int mColorHandle; ++ ++ /** How many bytes per float. */ ++ private final int mBytesPerFloat = 4; ++ ++ /** How many elements per vertex. */ ++ private final int mStrideBytes = 7 * mBytesPerFloat; ++ ++ /** Offset of the position data. */ ++ private final int mPositionOffset = 0; ++ ++ /** Size of the position data in elements. */ ++ private final int mPositionDataSize = 3; ++ ++ /** Offset of the color data. */ ++ private final int mColorOffset = 3; ++ ++ /** Size of the color data in elements. */ ++ private final int mColorDataSize = 4; ++ ++ public MyGLRenderer(float[][] vertices) ++ { ++ triangleData2DArr = new float[vertices.length][21]; ++ triangleVert = new FloatBuffer[vertices.length]; ++ ++ for (int i = 0; i < vertices.length; i++) ++ { ++ for (int j = 0; j < 21; j++) ++ triangleData2DArr[i][j] = vertices[i][j]; ++ } ++ ++ // initialize vertex byte buffer for shape coordinates ++ for (int i = 0; i < vertices.length; i++) ++ { ++ triangleVert[i] = ByteBuffer.allocateDirect(triangleData2DArr[i].length * mBytesPerFloat) ++ .order(ByteOrder.nativeOrder()).asFloatBuffer(); ++ triangleVert[i].put(triangleData2DArr[i]).position(0); ++ } ++ } ++ ++ public void onSurfaceCreated(GL10 unused, EGLConfig config) ++ { ++ // Set the background frame color ++ GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); ++ ++ // Position the eye behind the origin. ++ final float eyeX = 0.0f; ++ final float eyeY = 0.0f; ++ final float eyeZ = 1.5f; ++ ++ // We are looking toward the distance ++ final float lookX = 0.0f; ++ final float lookY = 0.0f; ++ final float lookZ = -5.0f; ++ ++ // Set our up vector. This is where our head would be pointing were we holding the camera. ++ final float upX = 0.0f; ++ final float upY = 1.0f; ++ final float upZ = 0.0f; ++ ++ // Set the view matrix. This matrix can be said to represent the camera position. ++ // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and ++ // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose. ++ mViewMatrix = new float[triangleVert.length][16]; ++ ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.setLookAtM(mViewMatrix[i], 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ); ++ ++ final String vertexShader = ++ "uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix. ++ + "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. ++ + "attribute vec4 a_Color; \n" // Per-vertex color information we will pass in. ++ + "varying vec4 v_Color; \n" // This will be passed into the fragment shader. ++ + "void main() \n" // The entry point for our vertex shader. ++ + "{ \n" ++ + " v_Color = a_Color; \n" // Pass the color through to the fragment shader. ++ // It will be interpolated across the triangle. ++ + " gl_Position = u_MVPMatrix \n" // gl_Position is a special variable used to store the final position. ++ + " * a_Position; \n" // Multiply the vertex by the matrix to get the final point in ++ + "} \n"; // normalized screen coordinates. ++ ++ final String fragmentShader = ++ "precision mediump float; \n" // Set the default precision to medium. We don't need as high of a // precision in the fragment shader. ++ + "varying vec4 v_Color; \n" // This is the color from the vertex shader interpolated across the ++ // triangle per fragment. ++ + "void main() \n" // The entry point for our fragment shader. ++ + "{ \n" ++ + " gl_FragColor = v_Color; \n" // Pass the color directly through the pipeline. ++ + "} \n"; ++ ++ ++ int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); ++ // Pass in the shader source. ++ GLES20.glShaderSource(vertexShaderHandle, vertexShader); ++ ++ // Compile the shader. ++ GLES20.glCompileShader(vertexShaderHandle); ++ ++ // Get the compilation status. ++ final int[] compileStatus1 = new int[1]; ++ GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus1, 0); ++ ++ // If the compilation failed, delete the shader. ++ if (compileStatus1[0] == 0) ++ { ++ GLES20.glDeleteShader(vertexShaderHandle); ++ vertexShaderHandle = 0; ++ } ++ ++ ++ int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); ++ // Pass in the shader source. ++ GLES20.glShaderSource(fragmentShaderHandle, fragmentShader); ++ ++ // Compile the shader. ++ GLES20.glCompileShader(fragmentShaderHandle); ++ ++ // Get the compilation status. ++ final int[] compileStatus2 = new int[1]; ++ GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus2, 0); ++ ++ // If the compilation failed, delete the shader. ++ if (compileStatus2[0] == 0) ++ { ++ GLES20.glDeleteShader(fragmentShaderHandle); ++ fragmentShaderHandle = 0; ++ } ++ ++ ++ int mProgram = GLES20.glCreateProgram(); ++ // Bind the vertex shader to the program. ++ GLES20.glAttachShader(mProgram, vertexShaderHandle); ++ ++ // Bind the fragment shader to the program. ++ GLES20.glAttachShader(mProgram, fragmentShaderHandle); ++ ++ // Bind attributes ++ GLES20.glBindAttribLocation(mProgram, 0, "a_Position"); ++ GLES20.glBindAttribLocation(mProgram, 1, "a_Color"); ++ ++ // Link the two shaders together into a program. ++ GLES20.glLinkProgram(mProgram); ++ ++ // Get the link status. ++ final int[] linkStatus = new int[1]; ++ GLES20.glGetProgramiv(mProgram, GLES20.GL_LINK_STATUS, linkStatus, 0); ++ ++ // If the link failed, delete the program. ++ if (linkStatus[0] == 0) ++ { ++ GLES20.glDeleteProgram(mProgram); ++ mProgram = 0; ++ } ++ ++ for (int i = 0; i < triangleVert.length; i++) ++ { ++ mMatrixHandle = GLES20.glGetUniformLocation(mProgram, "u_MVPMatrix"); ++ mPositionHandle = GLES20.glGetAttribLocation(mProgram, "a_Position"); ++ mColorHandle = GLES20.glGetAttribLocation(mProgram, "a_Color"); ++ } ++ ++ // Add program to OpenGL environment ++ GLES20.glUseProgram(mProgram); ++ } ++ ++ public void onSurfaceChanged(GL10 unused, int width, int height) ++ { ++ // Adjust the viewport based on geometry changes, ++ // such as screen rotation ++ GLES20.glViewport(0, 0, width, height); ++ ++ // Create a new perspective projection matrix. The height will stay the same ++ // while the width will vary as per aspect ratio. ++ final float ratio = (float) width / height; ++ ++ mProjectionMatrix = new float[triangleVert.length][16]; ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.frustumM(mProjectionMatrix[i], 0, -ratio*0.5f, ratio*1.0f, 0.0f, 1.0f, 1.0f, 14f); ++ //Matrix.frustumM(m, offset, left, right, bottom, top, near, far) ++ } ++ ++ public void onDrawFrame(GL10 glUnused) ++ { ++ // Draw background color ++ GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); ++ ++ mModelMatrix = new float[triangleVert.length][16]; ++ // Draw the triangle facing straight on. ++ for (int i = 0; i < triangleVert.length; i++) ++ Matrix.setIdentityM(mModelMatrix[i], 0); ++ ++ mMVPMatrix = new float[triangleVert.length][16]; ++ draw(triangleVert); ++ ++ } ++ ++ private void draw(final FloatBuffer[] aTriangleBuffer) ++ { ++ for (int i = 0; i < aTriangleBuffer.length; i++) ++ { ++ // Pass in the position information ++ aTriangleBuffer[i].position(mPositionOffset); ++ GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false, ++ mStrideBytes, aTriangleBuffer[i]); ++ ++ GLES20.glEnableVertexAttribArray(mPositionHandle); ++ ++ ++ // Pass in the color information ++ aTriangleBuffer[i].position(mColorOffset); ++ GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false, ++ mStrideBytes, aTriangleBuffer[i]); ++ ++ GLES20.glEnableVertexAttribArray(mColorHandle); ++ ++ //Matrix.setRotateM(mModelMatrix[i], 0, mAngle, 0, 0, -1.0f); ++ ++ // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix ++ // (which currently contains model * view). ++ Matrix.multiplyMM(mMVPMatrix[i], 0, mViewMatrix[i], 0, mModelMatrix[i], 0); ++ ++ // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix ++ // (which now contains model * view * projection). ++ Matrix.multiplyMM(mMVPMatrix[i], 0, mProjectionMatrix[i], 0, mMVPMatrix[i], 0); ++ ++ GLES20.glUniformMatrix4fv(mMatrixHandle, 1, false, mMVPMatrix[i], 0); ++ ++ // Draw the triangle ++ GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3); ++ ++ // Disable vertex array ++ GLES20.glDisableVertexAttribArray(mPositionHandle); ++ } ++ } ++ ++} +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/ISSM.java (revision 14109) +@@ -5,7 +5,9 @@ + import java.nio.ByteBuffer; + import java.nio.ByteOrder; + import java.nio.DoubleBuffer; ++import java.text.DecimalFormat; + ++import android.opengl.GLSurfaceView; + import android.os.Bundle; + import android.app.Activity; + import android.content.res.AssetManager; +@@ -15,6 +17,8 @@ + import android.view.View.OnClickListener; + import android.widget.Button; + import android.widget.EditText; ++import android.widget.FrameLayout; ++import android.widget.SeekBar; + import android.widget.TextView; + + +@@ -27,6 +31,12 @@ + private String mapName; + private String issmFolder; + private int size; ++ private GLSurfaceView mGLView; ++ private FrameLayout frame; ++ private SeekBar bar; ++ private TextView /*txtStatus,*/ txtValue; ++ ++ + @Override + //------------------------------------------------------------------------------------------------ + public void onCreate(Bundle savedInstanceState) { +@@ -40,8 +50,8 @@ + } + } + setContentView(R.layout.activity_issm); +- this.input = (EditText) super.findViewById(R.id.input); +- this.output = (TextView) super.findViewById(R.id.output); ++ this.bar = (SeekBar) findViewById(R.id.seekBar); ++ this.txtValue = (TextView) super.findViewById(R.id.value); + Button button = (Button) super.findViewById(R.id.button1); + button.setOnClickListener(this); + +@@ -50,6 +60,8 @@ + issmNative = new IssmJni(); + this.createModel(); + buff = ByteBuffer.allocateDirect(size*12*8).order(ByteOrder.nativeOrder()).asDoubleBuffer(); ++ ++ + } + //------------------------------------------------------------------------------------------------ + public void createModel() +@@ -68,28 +80,21 @@ + public void fillBuffer() + { + issmNative.solveISSMModel(5,buff); +- +- //for(int i=0;i< size*12;i++) +- //System.out.println(buff.get(i)); +- + } + //------------------------------------------------------------------------------------------------ + public void onClick(View view) + { + //factorial method +- String input = this.input.getText().toString(); ++ /*String input = this.input.getText().toString(); + if(TextUtils.isEmpty(input)) + { + return; +- } +- long resultfromFac = issmNative.fac(Long.parseLong(input)); ++ }*/ + //example of how to fill buffer Native + this.fillBuffer(); + +- //print result from fac and the first two slot of filled buffer. +- this.output.setText("Result = " + resultfromFac + "\n" +- + "First slot from buffer:\n" +- + buff.get(0) + " size " + size); +- ++ mGLView = new MyGLSurfaceView(this, buff, size); ++ frame = (FrameLayout)findViewById(R.id.frame); ++ frame.addView(mGLView); + } + } +Index: ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLSurfaceView.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLSurfaceView.java (revision 0) ++++ ../trunk-jpl/src/android/ISSM/src/com/example/issm/MyGLSurfaceView.java (revision 14109) +@@ -0,0 +1,233 @@ ++package com.example.issm; ++ ++import java.nio.DoubleBuffer; ++ ++import android.content.Context; ++import android.opengl.GLSurfaceView; ++import android.view.MotionEvent; ++ ++ ++class MyGLSurfaceView extends GLSurfaceView ++{ ++ private MyGLRenderer mRend; ++ private int iter = 0; ++ DoubleBuffer db; ++ int size; ++ double vmax = 0, vmin=0; ++ final int rowNumber = 64; ++ double[][] colorMap = { ++ { 1.0000, 0, 0 }, ++ { 1.0000, 0.0938 , 0 }, ++ { 1.0000, 0.1875 , 0}, ++ { 1.0000, 0.2812 , 0}, ++ { 1.0000, 0.3750 , 0}, ++ { 1.0000, 0.4688 , 0}, ++ { 1.0000, 0.5625 , 0}, ++ { 1.0000, 0.6562 , 0}, ++ { 1.0000, 0.7500 , 0}, ++ { 1.0000, 0.8438 , 0}, ++ { 1.0000, 0.9375 , 0}, ++ { 0.9688, 1.0000 , 0}, ++ { 0.8750, 1.0000 , 0}, ++ { 0.7812, 1.0000 , 0}, ++ { 0.6875, 1.0000 , 0}, ++ { 0.5938, 1.0000 , 0}, ++ { 0.5000, 1.0000 , 0}, ++ { 0.4062, 1.0000 , 0}, ++ { 0.3125, 1.0000 , 0}, ++ { 0.2188, 1.0000 , 0}, ++ { 0.1250, 1.0000 , 0}, ++ { 0.0312, 1.0000, 0}, ++ { 0, 1.0000, 0.0625}, ++ { 0, 1.0000, 0.1562}, ++ { 0, 1.0000, 0.2500}, ++ { 0, 1.0000, 0.3438}, ++ { 0, 1.0000, 0.4375}, ++ { 0, 1.0000, 0.5312}, ++ { 0, 1.0000, 0.6250}, ++ { 0, 1.0000, 0.7188}, ++ { 0, 1.0000, 0.8125}, ++ { 0, 1.0000, 0.9062}, ++ { 0, 1.0000, 1.0000}, ++ { 0, 0.9062, 1.0000}, ++ { 0, 0.8125, 1.0000}, ++ { 0, 0.7188, 1.0000}, ++ { 0, 0.6250, 1.0000}, ++ { 0, 0.5312, 1.0000}, ++ { 0, 0.4375, 1.0000}, ++ { 0, 0.3438, 1.0000}, ++ { 0, 0.2500, 1.0000}, ++ { 0, 0.1562, 1.0000}, ++ { 0, 0.0625, 1.0000}, ++ { 0.0312, 0, 1.0000}, ++ { 0.1250, 0, 1.0000}, ++ { 0.2188, 0, 1.0000}, ++ { 0.3125, 0, 1.0000}, ++ { 0.4062, 0, 1.0000}, ++ { 0.5000, 0, 1.0000}, ++ { 0.5938, 0, 1.0000}, ++ { 0.6875, 0, 1.0000}, ++ { 0.7812, 0, 1.0000}, ++ { 0.8750, 0, 1.0000}, ++ { 0.9688, 0, 1.0000}, ++ { 1.0000, 0, 0.9375}, ++ { 1.0000, 0, 0.8438}, ++ { 1.0000, 0, 0.7500}, ++ { 1.0000, 0, 0.6562}, ++ { 1.0000, 0, 0.5625}, ++ { 1.0000, 0, 0.4688}, ++ { 1.0000, 0, 0.3750}, ++ { 1.0000, 0, 0.2812}, ++ { 1.0000, 0, 0.1875}, ++ { 1.0000, 0, 0.0938}}; ++ float[][] colorMapInFloat; ++ public MyGLSurfaceView(Context context, DoubleBuffer db, int size) ++ { ++ super(context); ++ ++ // Create an OpenGL ES 2.0 context. ++ setEGLContextClientVersion(2); ++ this.db = db; ++ this.size = size; ++ colorMapInFloat = new float[64][3]; ++ ++ for (int i = 0 ; i < 64; i++) ++ { ++ for (int j = 0 ; j < 3; j++) ++ { ++ colorMapInFloat[i][j] = (float) colorMap[i][j]; ++ } ++ } ++ vmin = db.get(9); ++ findMinMaxVelocity(); ++ System.out.println("max" +vmax +" "+ "min"+vmin ); ++ intialize(); ++ } ++ private void intialize() ++ { ++ final int NMAX_TRIANGLES = 2000; ++ final int MAX_VERTICES = 21; ++ float f[][] = new float[size][MAX_VERTICES]; ++ int n, random; ++ final int SCALE_FACTOR = 700000; ++ for (int i = 0; i < size; i++) ++ { ++ f[i][0] = (float)db.get(12*i+0)/SCALE_FACTOR; ++ f[i][1] = (float)db.get(12*i+1)/SCALE_FACTOR; ++ f[i][2] = (float)db.get(12*i+2)/SCALE_FACTOR; ++ f[i][7] = (float)db.get(12*i+3)/SCALE_FACTOR; ++ f[i][8] = (float)db.get(12*i+4)/SCALE_FACTOR; ++ f[i][9] = (float)db.get(12*i+5)/SCALE_FACTOR; ++ f[i][14] = (float)db.get(12*i+6)/SCALE_FACTOR; ++ f[i][15] = (float)db.get(12*i+7)/SCALE_FACTOR; ++ f[i][16] = (float)db.get(12*i+8)/SCALE_FACTOR; ++ ++ f[i][6] = 1.0f; ++ f[i][13] = 1.0f; ++ f[i][20] = 1.0f; ++ ++ int index1 = getRowColor(db.get(12*i+9)); ++ int index2 = getRowColor(db.get(12*i+10)); ++ int index3 = getRowColor(db.get(12*i+11)); ++ ++ float r1 = colorMapInFloat[index1][0]; ++ float g1 = colorMapInFloat[index1][1]; ++ float b1 = colorMapInFloat[index1][2]; ++ ++ float r2 = colorMapInFloat[index2][0]; ++ float g2 = colorMapInFloat[index2][1]; ++ float b2 = colorMapInFloat[index2][2]; ++ ++ float r3 = colorMapInFloat[index3][0]; ++ float g3 = colorMapInFloat[index3][1]; ++ float b3 = colorMapInFloat[index3][2]; ++ ++ ++ f[i][3] = r1; ++ f[i][4] = g1; ++ f[i][5] = b1; ++ ++ f[i][10] = r2; ++ f[i][11] = g2; ++ f[i][12] = b2; ++ ++ f[i][17] = r3; ++ f[i][18] = g3; ++ f[i][19] = b3; ++ ++ } ++ mRend = new MyGLRenderer(f); ++ // Set the Renderer for drawing on the GLSurfaceView ++ setRenderer(mRend); ++ ++ // Render the view only when there is a change in the drawing data ++ setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); ++ } ++ private void findMinMaxVelocity() ++ { ++ for(int i = 0; i < size*12; i++) ++ { ++ if(i%12==9 || i%12==10 ||i%12==11 ) ++ { ++ if (db.get(i) < vmin) vmin = db.get(i); ++ if (db.get(i) >= vmax) vmax = db.get(i); ++ } ++ else continue; ++ } ++ ++ } ++ private float getData() ++ { ++ float result = (float) db.get(iter)/1000000; ++ //System.out.println("result" + result); ++ if(iter < size*12) iter++; ++ else iter = 0; ++ return result; ++ } ++ ++ private int getRowColor(double velocity) ++ { ++ //velocity = 0; ++ double alpha=(vmax-velocity)/(vmax-vmin) ; ++ int row = (int) (alpha * (rowNumber-1)); ++ return row; ++ } ++ ++ private final float TOUCH_SCALE_FACTOR = 180.0f / 320; ++ private float mPreviousX; ++ ++ private float mPreviousY; ++ @Override ++ public boolean onTouchEvent(MotionEvent e) { ++ // MotionEvent reports input details from the touch screen ++ // and other input controls. In this case, you are only ++ // interested in events where the touch position changed. ++ ++ float x = e.getX(); ++ float y = e.getY(); ++ ++ switch (e.getAction()) { ++ case MotionEvent.ACTION_MOVE: ++ ++ float dx = x - mPreviousX; ++ float dy = y - mPreviousY; ++ ++ // reverse direction of rotation above the mid-line ++ if (y > getHeight() / 2) { ++ dx = dx * -1 ; ++ } ++ ++ // reverse direction of rotation to left of the mid-line ++ if (x < getWidth() / 2) { ++ dy = dy * -1 ; ++ } ++ ++ mRend.mAngle += (dx + dy) * TOUCH_SCALE_FACTOR; // = 180.0f / 320 ++ requestRender(); ++ } ++ ++ mPreviousX = x; ++ mPreviousY = y; ++ return true; ++ } ++} +\ No newline at end of file +Index: ../trunk-jpl/src/android/ISSM/gen/com/example/issm/R.java +=================================================================== +--- ../trunk-jpl/src/android/ISSM/gen/com/example/issm/R.java (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/gen/com/example/issm/R.java (revision 14109) +@@ -20,11 +20,13 @@ + public static final int ic_launcher=0x7f020001; + } + public static final class id { +- public static final int button1=0x7f080001; +- public static final int button2=0x7f080003; +- public static final int input=0x7f080000; +- public static final int menu_settings=0x7f080004; +- public static final int output=0x7f080002; ++ public static final int button1=0x7f080004; ++ public static final int button2=0x7f080005; ++ public static final int frame=0x7f080003; ++ public static final int menu_settings=0x7f080006; ++ public static final int relativeLay=0x7f080000; ++ public static final int seekBar=0x7f080001; ++ public static final int value=0x7f080002; + } + public static final class layout { + public static final int activity_issm=0x7f030000; +Index: ../trunk-jpl/src/android/ISSM/res/layout/activity_issm.xml +=================================================================== +--- ../trunk-jpl/src/android/ISSM/res/layout/activity_issm.xml (revision 14108) ++++ ../trunk-jpl/src/android/ISSM/res/layout/activity_issm.xml (revision 14109) +@@ -1,33 +1,44 @@ + ++ android:layout_height="match_parent" ++ android:orientation="horizontal" > + +- ++ android:layout_marginBottom="41dp" /> + +-