int
hermite( int n, int x )
{
/*
** Do special cases where no recursion is required.
*/
if( n <= 0 )
return 1;
if( n == 1 )
return 2 * x;
/*
** Otherwise, recursively compute value.
*/
return 2 * x * hermite( n - 1, x ) -
2 * ( n - 1 ) * hermite( n - 2, x );
}
void wypelnijMacierze(matrix_t *eqs, points_t *pts, int n){
double *x = pts->x;
double *y = pts->y;
int i, j, k;
double suma;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++){
for (k = 0; k < pts->n; k++)
suma += hermite(x[k], i) * hermite(x[k], j);
add_to_entry_matrix(eqs, i, j, suma);
suma = 0;
}
for (k = 0; k < pts->n; k++)
suma += y[k] * hermite(x[k], i);
add_to_entry_matrix(eqs, i, n, suma);
suma = 0;
}
}
double ho_wvfxn(int n, double x, double xcen, double omega, double m, double hbar)
{ //nth harmonic oscillator solution evaluated at x, centered at xcen
double coeff1 = 1/sqrt(pow(2.0,n)*factorial(n));
double coeff2 = sqrt(sqrt(m*omega/M_PI/hbar));
double coeff = coeff1 * coeff2;
x -= xcen;
double fxn = coeff * exp(-1*m*omega*x*x/2/hbar) * hermite(n,sqrt(m*omega/hbar)*x);
return fxn;
}
//递归调用在n=3,x=2 时，y = 40；
int hermite( int n, int x)
{
int y;
//y = 0;
if( n <= 0 )
y = 1;
else if( n ==1 )
y = 2 * x;
else
y = 2 * x *hermite( n-1, x ) - 2 * ( n-1 ) *hermite( n-2, x );
/*
{
y = 2 * x *hermite( n-1, x );
y = y - 2 * ( n-1 ) *hermite( n-2, x );
}
*/
return y;
}
void WindowHermite::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
hermite(point3(-1,0,0), point3(1,0,0), point3(4,4,0), point3(4,4,0));
glFlush();
}
// calculate the weights for the hermite polynomial
// at the roots
// using formula Abramowitz and Stegun chapter 25.4.46 p.890
void hermite_weight(long n, double * hroot, double * weights)
{
long i;
double hr2;
double nominator = exp(LOG2 * ( n-1.) + logfac(n)) * SQRTPI / (n*n);
for(i=0;i<n; i++)
{
hr2 = hermite(n-1, hroot[i]);
weights[i] = nominator / (hr2*hr2);
}
}
int
main(int argc, char **argv)
{
int i;
for (i = 0; i <= 30; i++)
{
printf("%d\n", hermite(i, 10));
}
getchar();
return EXIT_SUCCESS;
}
// calculate the weights for the hermite polynomial
// at the roots
// using formula Abramowitz and Stegun chapter 25.4.46 p.890
void
hermite_weight (long n, MYREAL *hroot, MYREAL *weights)
{
long i;
MYREAL hr2;
MYREAL nominator = EXP (LOG2 * (n - 1.) + logfac (n)) * SQRTPI / (n * n);
for (i = 0; i < n; i++)
{
hr2 = hermite (n - 1, hroot[i]);
weights[i] = nominator / (hr2 * hr2);
}
}
void quaterN::hermite0(const quater& a, const quater& b, int duration, const quater& c, const quater& d, float interval)
{
quater qi(1,0,0,0);
hermite(a,b,duration, qi, qi, interval);
quaterN temp;
temp.hermite(qi,qi,duration, c, d, interval);
float totalTime=duration+1;
for(int i=0; i<duration; i++)
{
row(i).slerp(row(i), temp.row(i), (float)(i+1)/totalTime );
}
}
static ex hermite_evalf(const ex& n, const ex& x, PyObject* parent)
{
if (not is_exactly_a<numeric>(x)
or not is_exactly_a<numeric>(n))
return hermite(n,x).hold();
// see http://dlmf.nist.gov/18.5.E13
numeric numn = ex_to<numeric>(n);
numeric numx = ex_to<numeric>(x);
std::vector<numeric> numveca, numvecb;
numveca.push_back(numn / *_num_2_p);
numveca.push_back(*_num1_2_p + (numn / *_num_2_p));
return pow(numx * (*_num2_p), numn) * hypergeometric_pFq(numveca, numvecb, -pow(numx, *_num2_p).inverse(), parent);
}
float CTrack::GetKey(float frame) {
int x,y=MAXKEY;
if (!numkey) return 0.0;
if ((numkey==1) || ((keys[0].frame>=frame) && (keys[0].frame>=0)))
return keys[0].data;
for (x=0; x<numkey; x++)
if ((frame<=keys[x].frame) && (y==MAXKEY)) y=x-1;
if (y==MAXKEY) return keys[numkey-1].data;
return hermite(keys[y].data,keys[y+1].data,
keys[y].an ,keys[y+1].bn,
(float)(frame-keys[y].frame)/(float)(keys[y+1].frame-keys[y].frame) );
}
void
dhermite(void)
{
push(cadr(p1));
push(p2);
derivative();
push_integer(2);
push(caddr(p1));
multiply();
multiply();
push(cadr(p1));
push(caddr(p1));
push_integer(-1);
add();
hermite();
multiply();
}
void make_spl(points_t * pts, spline_t * spl){
matrix_t *eqs= NULL;
double *x = pts->x;
double *y = pts->y;
int i, j, k;
int n = pts->n > 8 ? 8 : pts->n;
double a = x[0];
double b = x[pts->n - 1];
char *nEnv= getenv( "APPROX_BASE_SIZE" );
if( nEnv != NULL && atoi( nEnv ) > 0 )
n = atoi( nEnv );
eqs = make_matrix(n, n+1);
wypelnijMacierze(eqs, pts, n);
if (piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
if (alloc_spl(spl, n) == 0) {
for (i = 0; i < spl->n; i++) {
double xx = spl->x[i] = a + i * (b - a)/(spl->n - 1);
xx+= 10.0 * DBL_EPSILON; // zabezpieczenie przed ulokowaniem punktu w poprzednim przedziale
spl->f[i] = 0;
spl->f1[i] = 0;
spl->f2[i] = 0;
spl->f3[i] = 0;
for (k = 0; k < n; k++) {
double ck = get_entry_matrix(eqs, k, n);
spl->f[i] += ck * hermite(xx, k);
spl->f1[i] += ck * hermiteD1(xx, k);
spl->f2[i] += ck * hermiteD2(xx, k);
spl->f3[i] += ck * hermiteD3(xx, k);
}
}
}
free(eqs);
free(x);
free(y);
}
void main(int argc, char **argv) {
real x[NMAX][NDIM], xdot[NMAX][NDIM], f[NMAX][NDIM],
/**/fdot[NMAX][NDIM];
real step[NMAX], tlast[NMAX], m[NMAX], t, dt;
long int j, i, n, nsteps, noutp, cpu, timenow;
extern void initialise(), runtime_output(), final_output();
/* cpu = clock(); */
time(&cpu);
srand(cpu);
assert(argc==4);
n = atoi(argv[1]);
noutp = atoi(argv[2]);
dt = atof(argv[3])/(real)noutp;
t = 0;
/* printf("\nInitial conditions.\n");*/
initialise(n, x, xdot, f, fdot, step, tlast, m);
nsteps=0;
loop(j, noutp) {
nsteps += hermite(x, xdot, f, fdot, step, tlast, m, &t,
/**/t+dt, n);
runtime_output(x,t,n);
}
static ex hermite_eval(const ex& n, const ex& x)
{
if (is_exactly_a<numeric>(x)) {
numeric numx = ex_to<numeric>(x);
if (numx.is_zero())
if (n.info(info_flags::integer)
and n.info(info_flags::odd))
return _ex0;
if (is_exactly_a<numeric>(n) and numx.info(info_flags::inexact))
return hermite_evalf(n, x, nullptr);
}
if (not is_exactly_a<numeric>(n))
return hermite(n, x).hold();
numeric numn = ex_to<numeric>(n);
if (not numn.info(info_flags::integer) or numn < 0)
throw std::runtime_error("hermite_eval: The index n must be a nonnegative integer");
if (numn.is_zero())
return _ex1;
// apply the formula from http://oeis.org/A060821
// T(n, k) = ((-1)^((n-k)/2))*(2^k)*n!/(k!*((n-k)/2)!) if n-k is even and >=0, else 0.
// sequentially for all viable k. Effectively there is the recurrence
// T(n, k) = -(k+2)*(k+1)/(2*(n-k)) * T(n, k+2), with T(n, n) = 2^n
numeric coeff = _num2_p->power(numn);
ex sum = _ex0;
int fac = 1;
while (numn >= 0) {
sum = sum + power(x, numn) * coeff;
coeff /= *_num_4_p;
coeff *= numn;
--numn;
coeff *= numn;
--numn;
coeff /= fac++;
}
return sum;
}
Vec2 hermite(const Vec2& value1, const Vec2& tangent1, const Vec2& value2,
const Vec2& tangent2, const float& amount)
{
return Vec2(hermite(value1.x, tangent1.x, value2.x, tangent2.x, amount),
hermite(value1.y, tangent1.y, value2.y, tangent2.y, amount));
}
void Basis_HGRAD_LINE_Hermite_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
const ArrayScalar & inputPoints,
const EOperator operatorType) const {
// Verify arguments
#ifdef HAVE_INTREPID_DEBUG
Intrepid::getValues_HGRAD_Args<Scalar, ArrayScalar>(outputValues,
inputPoints,
operatorType,
this -> getBaseCellTopology(),
this -> getCardinality() );
#endif
// Number of evaluation points = dim 0 of inputPoints
int nPts = inputPoints.dimension(0);
int nBf = this->getCardinality();
int n = nBf/2;
// Legendre polynomials and their derivatives evaluated on inputPoints
SerialDenseMatrix legendre(nBf,nPts);
// Hermite interpolants evaluated on inputPoints
SerialDenseMatrix hermite(nBf,nPts);
ArrayScalar P (nBf);
ArrayScalar Px(nBf);
int derivative_order;
int derivative_case = static_cast<int>(operatorType);
if( derivative_case == 0 ) {
derivative_order = 0;
}
else if( derivative_case > 0 && derivative_case < 5 ) {
derivative_order = 1;
}
else {
derivative_order = derivative_case - 3;
}
try {
// GRAD,CURL,DIV, and D1 are all the first derivative
switch (operatorType) {
case OPERATOR_VALUE:
{
for( int i=0; i<nPts; ++i ) {
recurrence( P, Px, inputPoints(i,0) );
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = P(j);
}
}
break;
}
case OPERATOR_GRAD:
case OPERATOR_DIV:
case OPERATOR_CURL:
case OPERATOR_D1:
{
for( int i=0; i<nPts; ++i ) {
recurrence( P, Px, inputPoints(i,0) );
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = Px(j);
}
}
break;
}
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10:
{
for( int i=0; i<nPts; ++i ) {
legendre_d( P, Px, derivative_order, inputPoints(i,0));
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = Px(j);
}
}
break;
}
default:
TEUCHOS_TEST_FOR_EXCEPTION( !( Intrepid::isValidOperator(operatorType) ), std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Hermite_FEM): Invalid operator type");
} // switch(operatorType)
}
catch (std::invalid_argument &exception){
TEUCHOS_TEST_FOR_EXCEPTION( true , std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Hermite_FEM): Operator failed");
}
if( !isFactored_ ) {
solver_.factorWithEquilibration(true);
solver_.factor();
}
solver_.setVectors(Teuchos::rcpFromRef(hermite),Teuchos::rcpFromRef(legendre));
solver_.solve();
if(derivative_order > 0)
{
for( int i=0; i<n; ++i ) {
for( int j=0; j<nPts; ++j ) {
outputValues(2*i, j,0) = hermite(i, j);
outputValues(2*i+1,j,0) = hermite(i+n,j);
}
}
}
else {
for( int i=0; i<n; ++i ) {
for( int j=0; j<nPts; ++j ) {
outputValues(2*i ,j) = hermite(i, j);
outputValues(2*i+1,j) = hermite(i+n,j);
}
}
}
} // getValues()
main(){
printf("%d", hermite(3,2));
}
Vec1 hermite(const Vec1& value1, const Vec1& tangent1, const Vec1& value2,
const Vec1& tangent2, const float& amount)
{
return Vec1(hermite(value1.x, tangent1.x, value2.x, tangent2.x, amount));
}
float lwEvalEnvelope( lwEnvelope *env, float time )
{
lwKey *key0, *key1, *skey, *ekey;
float t, h1, h2, h3, h4, in, out, offset = 0.0f;
int noff;
/* if there's no key, the value is 0 */
if ( env->nkeys == 0 ) return 0.0f;
/* if there's only one key, the value is constant */
if ( env->nkeys == 1 )
return env->key->value;
/* find the first and last keys */
skey = ekey = env->key;
while ( ekey->next ) ekey = ekey->next;
/* use pre-behavior if time is before first key time */
if ( time < skey->time ) {
switch ( env->behavior[ 0 ] )
{
case BEH_RESET:
return 0.0f;
case BEH_CONSTANT:
return skey->value;
case BEH_REPEAT:
time = range( time, skey->time, ekey->time, NULL );
break;
case BEH_OSCILLATE:
time = range( time, skey->time, ekey->time, &noff );
if ( noff % 2 )
time = ekey->time - skey->time - time;
break;
case BEH_OFFSET:
time = range( time, skey->time, ekey->time, &noff );
offset = noff * ( ekey->value - skey->value );
break;
case BEH_LINEAR:
switch ( skey->shape ) {
case SHAPE_STEP:
return skey->value;
case SHAPE_LINE:
return ( skey->value - skey->next->value )
/ ( skey->time - skey->next->time )
* ( time - skey->next->time )
+ skey->next->value;
case SHAPE_TCB:
case SHAPE_HERM:
case SHAPE_BEZI:
out = outgoing( skey, (Key*)(skey->next) )
/ ( skey->next->time - skey->time );
return out * ( time - skey->time ) + skey->value;
case SHAPE_BEZ2:
return ( skey->param[ 1 ] - skey->param[ 3 ] )
/ ( skey->param[ 0 ] - skey->param[ 2 ] )
* ( time - skey->time )
+ skey->value;
}
}
}
/* use post-behavior if time is after last key time */
else if ( time > ekey->time ) {
switch ( env->behavior[ 1 ] )
{
case BEH_RESET:
return 0.0f;
case BEH_CONSTANT:
return ekey->value;
case BEH_REPEAT:
time = range( time, skey->time, ekey->time, NULL );
break;
case BEH_OSCILLATE:
time = range( time, skey->time, ekey->time, &noff );
if ( noff % 2 )
time = ekey->time - skey->time - time;
break;
case BEH_OFFSET:
time = range( time, skey->time, ekey->time, &noff );
offset = noff * ( ekey->value - skey->value );
break;
case BEH_LINEAR:
switch ( ekey->shape ) {
case SHAPE_STEP:
return ekey->value;
case SHAPE_LINE:
return ( ekey->value - ekey->prev->value )
/ ( ekey->time - ekey->prev->time )
* ( time - ekey->prev->time )
+ ekey->prev->value;
case SHAPE_TCB:
case SHAPE_HERM:
case SHAPE_BEZI:
in = incoming( (Key*)(ekey->prev), (Key*)ekey )
/ ( ekey->time - ekey->prev->time );
return in * ( time - ekey->time ) + ekey->value;
case SHAPE_BEZ2:
return ( ekey->param[ 3 ] - ekey->param[ 1 ] )
/ ( ekey->param[ 2 ] - ekey->param[ 0 ] )
* ( time - ekey->time )
+ ekey->value;
}
}
}
/* get the endpoints of the interval being evaluated */
key0 = env->key;
while ( time > key0->next->time )
key0 = key0->next;
key1 = key0->next;
/* check for singularities first */
if ( time == key0->time )
return key0->value + offset;
else if ( time == key1->time )
return key1->value + offset;
/* get interval length, time in [0, 1] */
t = ( time - key0->time ) / ( key1->time - key0->time );
/* interpolate */
switch ( key1->shape )
{
case SHAPE_TCB:
case SHAPE_BEZI:
case SHAPE_HERM:
out = outgoing( key0, (Key*)key1 );
in = incoming( (Key*)key0, (Key*)key1 );
hermite( t, &h1, &h2, &h3, &h4 );
return h1 * key0->value + h2 * key1->value + h3 * out + h4 * in + offset;
case SHAPE_BEZ2:
return bez2( (Key*)key0, (Key*)key1, time ) + offset;
case SHAPE_LINE:
return key0->value + t * ( key1->value - key0->value ) + offset;
case SHAPE_STEP:
return key0->value + offset;
default:
return offset;
}
}
void skipping(int x) {
cleardevice();
std::vector<Point2D> neck, body, h1, h2, a1, a2, l1, l2, f1, f2;
neck.push_back(Point2D(x-5, 120)); neck.push_back(Point2D(x-5, 130));
neck.push_back(Point2D(x+5, 130)); neck.push_back(Point2D(x+5, 120));
body.push_back(Point2D(x-40, 130)); body.push_back(Point2D(x+40, 130));
body.push_back(Point2D(x+40, 200)); body.push_back(Point2D(x-40, 200));
h1.push_back(Point2D(x-40, 130)); h1.push_back(Point2D(x-40, 140));
h1.push_back(Point2D(x-55, 165)); h1.push_back(Point2D(x-55, 155));
h2.push_back(Point2D(x+40, 130)); h2.push_back(Point2D(x+40, 140));
h2.push_back(Point2D(x+55, 165)); h2.push_back(Point2D(x+55, 155));
a1.push_back(Point2D(x-75, 140)); a1.push_back(Point2D(x-75, 150));
a1.push_back(Point2D(x-55, 165)); a1.push_back(Point2D(x-55, 155));
a2.push_back(Point2D(x+75, 140)); a2.push_back(Point2D(x+75, 150));
a2.push_back(Point2D(x+55, 165)); a2.push_back(Point2D(x+55, 155));
l1.push_back(Point2D(x-30, 200)); l1.push_back(Point2D(x-30, 260));
l1.push_back(Point2D(x-20, 260)); l1.push_back(Point2D(x-20, 200));
l2.push_back(Point2D(x+30, 200)); l2.push_back(Point2D(x+30, 260));
l2.push_back(Point2D(x+20, 260)); l2.push_back(Point2D(x+20, 200));
f1.push_back(Point2D(x-32, 260)); f1.push_back(Point2D(x-32, 265));
f1.push_back(Point2D(x-18, 265)); f1.push_back(Point2D(x-18, 260));
f2.push_back(Point2D(x+32, 260)); f2.push_back(Point2D(x+32, 265));
f2.push_back(Point2D(x+18, 265)); f2.push_back(Point2D(x+18, 260));
mycircle(x, 100, 20);
mypoly(body); mypoly(neck);
mypoly(h1); mypoly(h2);
mypoly(a1); mypoly(a2);
mypoly(l1); mypoly(l2);
mypoly(f1); mypoly(f2);
float y1 = a1[0].y, d = 30/50;
setfillstyle(SOLID_FILL, RED);
floodfill(x, 150, WHITE);
int k = 500;
bool inc = true;
do {
setcolor(YELLOW);
hermite(a1[0].x, a1[0].y + 5, a2[0].x, a1[0].y + 5, 5, -k, -5, k);
setcolor(WHITE);
circle(x, 100, 20);
mypoly(body); mypoly(neck);
mypoly(h1); mypoly(h2);
mypoly(a1); mypoly(a2);
mypoly(l1); mypoly(l2);
mypoly(f1); mypoly(f2);
delay(100);
setcolor(BLACK);
hermite(a1[0].x, a1[0].y + 5, a2[0].x, a1[0].y + 5, 5, -k, -5, k);
if(k <= -500)
inc = false;
if(inc) {
k -= 10;
y1 += d;
a1[0].y = rnd(y1) ;
a1[1].y = rnd(y1) + 10;
a2[0].y = rnd(y1) ;
a2[1].y = rnd(y1) + 10;
}
else {
k += 10;
y1 -= d;
a1[0].y = rnd(y1) ;
a1[1].y = rnd(y1) + 10;
a2[0].y = rnd(y1) ;
a2[1].y = rnd(y1) + 10;
}
}while(k != 500);
getch();
}
int test_main(int, char* [])
{
int i;
TEST_POLICY_SF(tgamma(3.0));
TEST_POLICY_SF(tgamma1pm1(0.25));
TEST_POLICY_SF(lgamma(50.0));
TEST_POLICY_SF(lgamma(50.0, &i));
TEST_POLICY_SF(digamma(12.0));
TEST_POLICY_SF(tgamma_ratio(12.0, 13.5));
TEST_POLICY_SF(tgamma_delta_ratio(100.0, 0.25));
TEST_POLICY_SF(factorial<double>(8));
TEST_POLICY_SF(unchecked_factorial<double>(3));
TEST_POLICY_SF(double_factorial<double>(5));
TEST_POLICY_SF(rising_factorial(20.5, 5));
TEST_POLICY_SF(falling_factorial(10.2, 7));
TEST_POLICY_SF(tgamma(12.0, 13.0));
TEST_POLICY_SF(tgamma_lower(12.0, 13.0));
TEST_POLICY_SF(gamma_p(12.0, 13.0));
TEST_POLICY_SF(gamma_q(12.0, 15.0));
TEST_POLICY_SF(gamma_p_inv(12.0, 0.25));
TEST_POLICY_SF(gamma_q_inv(15.0, 0.25));
TEST_POLICY_SF(gamma_p_inva(12.0, 0.25));
TEST_POLICY_SF(gamma_q_inva(12.0, 0.25));
TEST_POLICY_SF(erf(2.5));
TEST_POLICY_SF(erfc(2.5));
TEST_POLICY_SF(erf_inv(0.25));
TEST_POLICY_SF(erfc_inv(0.25));
TEST_POLICY_SF(beta(12.0, 15.0));
TEST_POLICY_SF(beta(12.0, 15.0, 0.25));
TEST_POLICY_SF(betac(12.0, 15.0, 0.25));
TEST_POLICY_SF(ibeta(12.0, 15.0, 0.25));
TEST_POLICY_SF(ibetac(12.0, 15.0, 0.25));
TEST_POLICY_SF(ibeta_inv(12.0, 15.0, 0.25));
TEST_POLICY_SF(ibetac_inv(12.0, 15.0, 0.25));
TEST_POLICY_SF(ibeta_inva(12.0, 0.75, 0.25));
TEST_POLICY_SF(ibetac_inva(12.0, 0.75, 0.25));
TEST_POLICY_SF(ibeta_invb(12.0, 0.75, 0.25));
TEST_POLICY_SF(ibetac_invb(12.0, 0.75, 0.25));
TEST_POLICY_SF(gamma_p_derivative(12.0, 15.0));
TEST_POLICY_SF(ibeta_derivative(12.0, 15.75, 0.25));
TEST_POLICY_SF(fpclassify(12.0));
TEST_POLICY_SF(isfinite(12.0));
TEST_POLICY_SF(isnormal(12.0));
TEST_POLICY_SF(isnan(12.0));
TEST_POLICY_SF(isinf(12.0));
TEST_POLICY_SF(log1p(0.0025));
TEST_POLICY_SF(expm1(0.0025));
TEST_POLICY_SF(cbrt(30.0));
TEST_POLICY_SF(sqrt1pm1(0.0025));
TEST_POLICY_SF(powm1(1.0025, 12.0));
TEST_POLICY_SF(legendre_p(5, 0.75));
TEST_POLICY_SF(legendre_p(7, 3, 0.75));
TEST_POLICY_SF(legendre_q(5, 0.75));
TEST_POLICY_SF(legendre_next(2, 0.25, 12.0, 5.0));
TEST_POLICY_SF(legendre_next(2, 2, 0.25, 12.0, 5.0));
TEST_POLICY_SF(laguerre(5, 12.2));
TEST_POLICY_SF(laguerre(7, 3, 5.0));
TEST_POLICY_SF(laguerre_next(2, 5.0, 12.0, 5.0));
TEST_POLICY_SF(laguerre_next(5, 3, 5.0, 20.0, 10.0));
TEST_POLICY_SF(hermite(1, 2.0));
TEST_POLICY_SF(hermite_next(2, 2.0, 3.0, 2.0));
TEST_POLICY_SF(spherical_harmonic_r(5, 4, 0.75, 0.25));
TEST_POLICY_SF(spherical_harmonic_i(5, 4, 0.75, 0.25));
TEST_POLICY_SF(ellint_1(0.25));
TEST_POLICY_SF(ellint_1(0.25, 0.75));
TEST_POLICY_SF(ellint_2(0.25));
TEST_POLICY_SF(ellint_2(0.25, 0.75));
TEST_POLICY_SF(ellint_3(0.25, 0.75));
TEST_POLICY_SF(ellint_3(0.25, 0.125, 0.75));
TEST_POLICY_SF(ellint_rc(3.0, 5.0));
TEST_POLICY_SF(ellint_rd(2.0, 3.0, 4.0));
TEST_POLICY_SF(ellint_rf(2.0, 3.0, 4.0));
TEST_POLICY_SF(ellint_rj(2.0, 3.0, 5.0, 0.25));
TEST_POLICY_SF(hypot(5.0, 3.0));
TEST_POLICY_SF(sinc_pi(3.0));
TEST_POLICY_SF(sinhc_pi(2.0));
TEST_POLICY_SF(asinh(12.0));
TEST_POLICY_SF(acosh(5.0));
TEST_POLICY_SF(atanh(0.75));
TEST_POLICY_SF(sin_pi(5.0));
TEST_POLICY_SF(cos_pi(6.0));
TEST_POLICY_SF(cyl_neumann(2.0, 5.0));
TEST_POLICY_SF(cyl_neumann(2, 5.0));
TEST_POLICY_SF(cyl_bessel_j(2.0, 5.0));
TEST_POLICY_SF(cyl_bessel_j(2, 5.0));
TEST_POLICY_SF(cyl_bessel_i(3.0, 5.0));
TEST_POLICY_SF(cyl_bessel_i(3, 5.0));
TEST_POLICY_SF(cyl_bessel_k(3.0, 5.0));
TEST_POLICY_SF(cyl_bessel_k(3, 5.0));
TEST_POLICY_SF(sph_bessel(3, 5.0));
TEST_POLICY_SF(sph_bessel(3, 5));
TEST_POLICY_SF(sph_neumann(3, 5.0));
TEST_POLICY_SF(sph_neumann(3, 5));
return 0;
}
Vec3 hermite(const Vec3& value1, const Vec3& tangent1, const Vec3& value2,
const Vec3& tangent2, const float& amount) {
return Vec3(hermite(value1.x, tangent1.x, value2.x, tangent2.x, amount),
hermite(value1.y, tangent1.y, value2.y, tangent2.y, amount),
hermite(value1.z, tangent1.z, value2.z, tangent2.z, amount));
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Error;
struct line_pnts *Points;
struct line_cats *Cats;
int i, type, iter;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *error_out, *thresh_opt, *method_opt,
*look_ahead_opt;
struct Option *iterations_opt, *cat_opt, *alpha_opt, *beta_opt, *type_opt;
struct Option *field_opt, *where_opt, *reduction_opt, *slide_opt;
struct Option *angle_thresh_opt, *degree_thresh_opt,
*closeness_thresh_opt;
struct Option *betweeness_thresh_opt;
struct Flag *notab_flag, *loop_support_flag;
int with_z;
int total_input, total_output; /* Number of points in the input/output map respectively */
double thresh, alpha, beta, reduction, slide, angle_thresh;
double degree_thresh, closeness_thresh, betweeness_thresh;
int method;
int look_ahead, iterations;
int loop_support;
int layer;
int n_lines;
int simplification, mask_type;
struct cat_list *cat_list = NULL;
char *s, *descriptions;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("generalization"));
G_add_keyword(_("simplification"));
G_add_keyword(_("smoothing"));
G_add_keyword(_("displacement"));
G_add_keyword(_("network generalization"));
module->description = _("Performs vector based generalization.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary,area";
type_opt->answer = "line,boundary,area";
type_opt->guisection = _("Selection");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out->key = "error";
error_out->required = NO;
error_out->description =
_("Error map of all lines and boundaries not being generalized due to topology issues or over-simplification");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options =
"douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement";
descriptions = NULL;
G_asprintf(&descriptions,
"douglas;%s;"
"douglas_reduction;%s;"
"lang;%s;"
"reduction;%s;"
"reumann;%s;"
"boyle;%s;"
"sliding_averaging;%s;"
"distance_weighting;%s;"
"chaiken;%s;"
"hermite;%s;"
"snakes;%s;"
"network;%s;"
"displacement;%s;",
_("Douglas-Peucker Algorithm"),
_("Douglas-Peucker Algorithm with reduction parameter"),
_("Lang Simplification Algorithm"),
_("Vertex Reduction Algorithm eliminates points close to each other"),
_("Reumann-Witkam Algorithm"),
_("Boyle's Forward-Looking Algorithm"),
_("McMaster's Sliding Averaging Algorithm"),
_("McMaster's Distance-Weighting Algorithm"),
_("Chaiken's Algorithm"),
_("Interpolation by Cubic Hermite Splines"),
_("Snakes method for line smoothing"),
_("Network generalization"),
_("Displacement of lines close to each other"));
method_opt->descriptions = G_store(descriptions);
method_opt->description = _("Generalization algorithm");
thresh_opt = G_define_option();
thresh_opt->key = "threshold";
thresh_opt->type = TYPE_DOUBLE;
thresh_opt->required = YES;
thresh_opt->options = "0-1000000000";
thresh_opt->description = _("Maximal tolerance value");
look_ahead_opt = G_define_option();
look_ahead_opt->key = "look_ahead";
look_ahead_opt->type = TYPE_INTEGER;
look_ahead_opt->required = NO;
look_ahead_opt->answer = "7";
look_ahead_opt->description = _("Look-ahead parameter");
reduction_opt = G_define_option();
reduction_opt->key = "reduction";
reduction_opt->type = TYPE_DOUBLE;
reduction_opt->required = NO;
reduction_opt->answer = "50";
reduction_opt->options = "0-100";
reduction_opt->description =
_("Percentage of the points in the output of 'douglas_reduction' algorithm");
slide_opt = G_define_option();
slide_opt->key = "slide";
slide_opt->type = TYPE_DOUBLE;
slide_opt->required = NO;
slide_opt->answer = "0.5";
slide_opt->options = "0-1";
slide_opt->description =
_("Slide of computed point toward the original point");
angle_thresh_opt = G_define_option();
angle_thresh_opt->key = "angle_thresh";
angle_thresh_opt->type = TYPE_DOUBLE;
angle_thresh_opt->required = NO;
angle_thresh_opt->answer = "3";
angle_thresh_opt->options = "0-180";
angle_thresh_opt->description =
_("Minimum angle between two consecutive segments in Hermite method");
degree_thresh_opt = G_define_option();
degree_thresh_opt->key = "degree_thresh";
degree_thresh_opt->type = TYPE_INTEGER;
degree_thresh_opt->required = NO;
degree_thresh_opt->answer = "0";
degree_thresh_opt->description =
_("Degree threshold in network generalization");
closeness_thresh_opt = G_define_option();
closeness_thresh_opt->key = "closeness_thresh";
closeness_thresh_opt->type = TYPE_DOUBLE;
closeness_thresh_opt->required = NO;
closeness_thresh_opt->answer = "0";
closeness_thresh_opt->options = "0-1";
closeness_thresh_opt->description =
_("Closeness threshold in network generalization");
betweeness_thresh_opt = G_define_option();
betweeness_thresh_opt->key = "betweeness_thresh";
betweeness_thresh_opt->type = TYPE_DOUBLE;
betweeness_thresh_opt->required = NO;
betweeness_thresh_opt->answer = "0";
betweeness_thresh_opt->description =
_("Betweeness threshold in network generalization");
alpha_opt = G_define_option();
alpha_opt->key = "alpha";
alpha_opt->type = TYPE_DOUBLE;
alpha_opt->required = NO;
alpha_opt->answer = "1.0";
alpha_opt->description = _("Snakes alpha parameter");
beta_opt = G_define_option();
beta_opt->key = "beta";
beta_opt->type = TYPE_DOUBLE;
beta_opt->required = NO;
beta_opt->answer = "1.0";
beta_opt->description = _("Snakes beta parameter");
iterations_opt = G_define_option();
iterations_opt->key = "iterations";
iterations_opt->type = TYPE_INTEGER;
iterations_opt->required = NO;
iterations_opt->answer = "1";
iterations_opt->description = _("Number of iterations");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
loop_support_flag = G_define_flag();
loop_support_flag->key = 'l';
loop_support_flag->label = _("Disable loop support");
loop_support_flag->description = _("Do not modify end points of lines forming a closed loop");
notab_flag = G_define_standard_flag(G_FLG_V_TABLE);
notab_flag->description = _("Do not copy attributes");
notab_flag->guisection = _("Attributes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
thresh = atof(thresh_opt->answer);
look_ahead = atoi(look_ahead_opt->answer);
alpha = atof(alpha_opt->answer);
beta = atof(beta_opt->answer);
reduction = atof(reduction_opt->answer);
iterations = atoi(iterations_opt->answer);
slide = atof(slide_opt->answer);
angle_thresh = atof(angle_thresh_opt->answer);
degree_thresh = atof(degree_thresh_opt->answer);
closeness_thresh = atof(closeness_thresh_opt->answer);
betweeness_thresh = atof(betweeness_thresh_opt->answer);
mask_type = type_mask(type_opt);
G_debug(3, "Method: %s", method_opt->answer);
s = method_opt->answer;
if (strcmp(s, "douglas") == 0)
method = DOUGLAS;
else if (strcmp(s, "lang") == 0)
method = LANG;
else if (strcmp(s, "reduction") == 0)
method = VERTEX_REDUCTION;
else if (strcmp(s, "reumann") == 0)
method = REUMANN;
else if (strcmp(s, "boyle") == 0)
method = BOYLE;
else if (strcmp(s, "distance_weighting") == 0)
method = DISTANCE_WEIGHTING;
else if (strcmp(s, "chaiken") == 0)
method = CHAIKEN;
else if (strcmp(s, "hermite") == 0)
method = HERMITE;
else if (strcmp(s, "snakes") == 0)
method = SNAKES;
else if (strcmp(s, "douglas_reduction") == 0)
method = DOUGLAS_REDUCTION;
else if (strcmp(s, "sliding_averaging") == 0)
method = SLIDING_AVERAGING;
else if (strcmp(s, "network") == 0)
method = NETWORK;
else if (strcmp(s, "displacement") == 0) {
method = DISPLACEMENT;
/* we can displace only the lines */
mask_type = GV_LINE;
}
else {
G_fatal_error(_("Unknown method"));
exit(EXIT_FAILURE);
}
/* simplification or smoothing? */
switch (method) {
case DOUGLAS:
case DOUGLAS_REDUCTION:
case LANG:
case VERTEX_REDUCTION:
case REUMANN:
simplification = 1;
break;
default:
simplification = 0;
break;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old2(&In, map_in->answer, "", field_opt->answer) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
if (Vect_get_num_primitives(&In, mask_type) == 0) {
G_warning(_("No lines found in input map <%s>"), map_in->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (error_out->answer) {
if (0 > Vect_open_new(&Error, error_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create error vector map <%s>"), error_out->answer);
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
total_input = total_output = 0;
layer = Vect_get_field_number(&In, field_opt->answer);
/* parse filter options */
if (layer > 0)
cat_list = Vect_cats_set_constraint(&In, layer,
where_opt->answer, cat_opt->answer);
if (method == DISPLACEMENT) {
/* modifies only lines, all other features including boundaries are preserved */
/* options where, cats, and layer are respected */
G_message(_("Displacement..."));
snakes_displacement(&In, &Out, thresh, alpha, beta, 1.0, 10.0,
iterations, cat_list, layer);
}
/* TODO: rearrange code below. It's really messy */
if (method == NETWORK) {
/* extracts lines of selected type, all other features are discarded */
/* options where, cats, and layer are ignored */
G_message(_("Network generalization..."));
total_output =
graph_generalization(&In, &Out, mask_type, degree_thresh,
closeness_thresh, betweeness_thresh);
}
/* copy tables here because method == NETWORK is complete and
* tables for Out may be needed for parse_filter_options() below */
if (!notab_flag->answer) {
if (method == NETWORK)
copy_tables_by_cats(&In, &Out);
else
Vect_copy_tables(&In, &Out, -1);
}
else if (where_opt->answer && method < NETWORK) {
G_warning(_("Attributes are needed for 'where' option, copying table"));
Vect_copy_tables(&In, &Out, -1);
}
/* smoothing/simplification */
if (method < NETWORK) {
/* modifies only lines of selected type, all other features are preserved */
int not_modified_boundaries = 0, n_oversimplified = 0;
struct line_pnts *APoints; /* original Points */
set_topo_debug();
Vect_copy_map_lines(&In, &Out);
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
G_message("-----------------------------------------------------");
G_message(_("Generalization (%s)..."), method_opt->answer);
G_message(_("Using threshold: %g %s"), thresh, G_database_unit_name(1));
G_percent_reset();
APoints = Vect_new_line_struct();
n_lines = Vect_get_num_lines(&Out);
for (i = 1; i <= n_lines; i++) {
int after = 0;
G_percent(i, n_lines, 1);
type = Vect_read_line(&Out, APoints, Cats, i);
if (!(type & GV_LINES) || !(mask_type & type))
continue;
if (layer > 0) {
if ((type & GV_LINE) &&
!Vect_cats_in_constraint(Cats, layer, cat_list))
continue;
else if ((type & GV_BOUNDARY)) {
int do_line = 0;
int left, right;
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
if (!do_line) {
/* check if any of the centroids is selected */
Vect_get_line_areas(&Out, i, &left, &right);
if (left < 0)
left = Vect_get_isle_area(&Out, abs(left));
if (right < 0)
right = Vect_get_isle_area(&Out, abs(right));
if (left > 0) {
Vect_get_area_cats(&Out, left, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
if (!do_line && right > 0) {
Vect_get_area_cats(&Out, right, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
}
if (!do_line)
continue;
}
}
Vect_line_prune(APoints);
if (APoints->n_points < 2)
/* Line of length zero, delete if boundary ? */
continue;
total_input += APoints->n_points;
/* copy points */
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
loop_support = 0;
if (!loop_support_flag->answer) {
int n1, n2;
Vect_get_line_nodes(&Out, i, &n1, &n2);
if (n1 == n2) {
if (Vect_get_node_n_lines(&Out, n1) == 2) {
if (abs(Vect_get_node_line(&Out, n1, 0)) == i &&
abs(Vect_get_node_line(&Out, n1, 1)) == i)
loop_support = 1;
}
}
}
for (iter = 0; iter < iterations; iter++) {
switch (method) {
case DOUGLAS:
douglas_peucker(Points, thresh, with_z);
break;
case DOUGLAS_REDUCTION:
douglas_peucker_reduction(Points, thresh, reduction,
with_z);
break;
case LANG:
lang(Points, thresh, look_ahead, with_z);
break;
case VERTEX_REDUCTION:
vertex_reduction(Points, thresh, with_z);
break;
case REUMANN:
reumann_witkam(Points, thresh, with_z);
break;
case BOYLE:
boyle(Points, look_ahead, loop_support, with_z);
break;
case SLIDING_AVERAGING:
sliding_averaging(Points, slide, look_ahead, loop_support, with_z);
break;
case DISTANCE_WEIGHTING:
distance_weighting(Points, slide, look_ahead, loop_support, with_z);
break;
case CHAIKEN:
chaiken(Points, thresh, loop_support, with_z);
break;
case HERMITE:
hermite(Points, thresh, angle_thresh, loop_support, with_z);
break;
case SNAKES:
snakes(Points, alpha, beta, loop_support, with_z);
break;
}
}
if (loop_support == 0) {
/* safety check, BUG in method if not passed */
if (APoints->x[0] != Points->x[0] ||
APoints->y[0] != Points->y[0] ||
APoints->z[0] != Points->z[0])
G_fatal_error(_("Method '%s' did not preserve first point"), method_opt->answer);
if (APoints->x[APoints->n_points - 1] != Points->x[Points->n_points - 1] ||
APoints->y[APoints->n_points - 1] != Points->y[Points->n_points - 1] ||
APoints->z[APoints->n_points - 1] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve last point"), method_opt->answer);
}
else {
/* safety check, BUG in method if not passed */
if (Points->x[0] != Points->x[Points->n_points - 1] ||
Points->y[0] != Points->y[Points->n_points - 1] ||
Points->z[0] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve loop"), method_opt->answer);
}
Vect_line_prune(Points);
/* oversimplified line */
if (Points->n_points < 2) {
after = APoints->n_points;
n_oversimplified++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
/* check for topology corruption */
else if (type == GV_BOUNDARY) {
if (!check_topo(&Out, i, APoints, Points, Cats)) {
after = APoints->n_points;
not_modified_boundaries++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
else
after = Points->n_points;
}
else {
/* type == GV_LINE */
Vect_rewrite_line(&Out, i, type, Points, Cats);
after = Points->n_points;
}
total_output += after;
}
if (not_modified_boundaries > 0)
G_warning(_("%d boundaries were not modified because modification would damage topology"),
not_modified_boundaries);
if (n_oversimplified > 0)
G_warning(_("%d lines/boundaries were not modified due to over-simplification"),
n_oversimplified);
G_message("-----------------------------------------------------");
/* make sure that clean topo is built at the end */
Vect_build_partial(&Out, GV_BUILD_NONE);
if (error_out->answer)
Vect_build_partial(&Error, GV_BUILD_NONE);
}
Vect_build(&Out);
if (error_out->answer)
Vect_build(&Error);
Vect_close(&In);
Vect_close(&Out);
if (error_out->answer)
Vect_close(&Error);
G_message("-----------------------------------------------------");
if (total_input != 0 && total_input != total_output)
G_done_msg(_("Number of vertices for selected features %s from %d to %d (%d%% remaining)"),
simplification ? _("reduced") : _("changed"),
total_input, total_output,
(total_output * 100) / total_input);
else
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
void right_hermite(Matrix *A,Matrix **Hp,Matrix **Up,Matrix **Qp) {
Matrix *H, *Q, *U;
int i, j, nr, nc, rank;
Value tmp;
/* Computes form: A = QH , UA = H */
nc = A->NbColumns;
nr = A->NbRows;
/* H = A */
*Hp = H = Matrix_Alloc(nr,nc);
if (!H) {
errormsg1("DomRightHermite", "outofmem", "out of memory space");
return;
}
/* Initialize all the 'Value' variables */
value_init(tmp);
Vector_Copy(A->p_Init,H->p_Init,nr*nc);
/* U = I */
if (Up) {
*Up = U = Matrix_Alloc(nr, nr);
if (!U) {
errormsg1("DomRightHermite", "outofmem", "out of memory space");
value_clear(tmp);
return;
}
Vector_Set(U->p_Init,0,nr*nr); /* zero's */
for(i=0;i<nr;i++) /* with diagonal of 1's */
value_set_si(U->p[i][i],1);
}
else
U = (Matrix *)0;
/* Q = I */
/* Actually I compute Q transpose... its easier */
if (Qp) {
*Qp = Q = Matrix_Alloc(nr,nr);
if (!Q) {
errormsg1("DomRightHermite", "outofmem", "out of memory space");
value_clear(tmp);
return;
}
Vector_Set(Q->p_Init,0,nr*nr); /* zero's */
for (i=0;i<nr;i++) /* with diagonal of 1's */
value_set_si(Q->p[i][i],1);
}
else
Q = (Matrix *)0;
rank = hermite(H,U,Q);
/* Q is returned transposed */
/* Transpose Q */
if (Q) {
for (i=0; i<nr; i++) {
for (j=i+1; j<nr; j++) {
value_assign(tmp,Q->p[i][j]);
value_assign(Q->p[i][j],Q->p[j][i] );
value_assign(Q->p[j][i],tmp);
}
}
}
value_clear(tmp);
return;
} /* right_hermite */
// n-th state of Harm.Osc. in terms of Hermite Polynomial
// and the constant alfan[n+1]
float PSI_n_form(float x, int n, float exp) {
return(alfan[n] * hermite(n, x) * exp);
}
double LWEnvelope::Evaluate(double Time)
{
if ( NumKeys == 0 )
return 0.0;
if ( NumKeys == 1 )
return Keys.begin()->value;
if(InternalCalculation)
{
float offset=0.0;
if (Time>EndTime)
Time=EndTime;
if (Time<StartTime)
Time=StartTime;
/* get the endpoints of the interval being evaluated */
std::list<LWKey>::iterator key0(Keys.begin());
std::list<LWKey>::iterator key1(Keys.begin());
while ( Time > (*(++key1)).Time ) // Hope this construction works!
{
key0 = key1;
}
/* check for singularities first */
if ( Time == (*key0).Time )
return (*key0).value + offset;
else if ( Time == (*key1).Time )
return (*key1).value + offset;
/* get interval length, time in [0, 1] */
float t = ( Time - (*key0).Time ) / ( (*key1).Time - (*key0).Time );
float out=0.0;
float in=0.0;
float h1,h2,h3,h4;
switch ( (*key1).shape )
{
case SHAPE_TCB:
case SHAPE_BEZI:
case SHAPE_HERM:
out = outgoing( key0, key1 );
in = incoming( key0, key1 );
hermite( t, &h1, &h2, &h3, &h4 );
return h1 * (*key0).value + h2 * (*key1).value + h3 * out + h4 * in + offset;
case SHAPE_BEZ2:
return 0.0;//bez2( key0, key1, time ) + offset;
case SHAPE_LINE:
return (*key0).value + t * ( (*key1).value - (*key0).value ) + offset;
case SHAPE_STEP:
return (*key0).value + offset;
default:
return offset;
}
double TheResult=1.0;
return TheResult;//Lightwave3D::chaninfo->channelEvaluate(EnvChannel,Time);
}
else
return Lightwave3D::chaninfo->channelEvaluate(EnvChannel,Time);
}
void left_hermite(Matrix *A,Matrix **Hp,Matrix **Qp,Matrix **Up) {
Matrix *H, *HT, *Q, *U;
int i, j, nc, nr, rank;
Value tmp;
/* Computes left form: A = HQ , AU = H ,
T T T T T T
using right form A = Q H , U A = H */
nr = A->NbRows;
nc = A->NbColumns;
/* HT = A transpose */
HT = Matrix_Alloc(nc, nr);
if (!HT) {
errormsg1("DomLeftHermite", "outofmem", "out of memory space");
return;
}
value_init(tmp);
for (i=0; i<nr; i++)
for (j=0; j<nc; j++)
value_assign(HT->p[j][i],A->p[i][j]);
/* U = I */
if (Up) {
*Up = U = Matrix_Alloc(nc,nc);
if (!U) {
errormsg1("DomLeftHermite", "outofmem", "out of memory space");
value_clear(tmp);
return;
}
Vector_Set(U->p_Init,0,nc*nc); /* zero's */
for (i=0;i<nc;i++) /* with diagonal of 1's */
value_set_si(U->p[i][i],1);
}
else U=(Matrix *)0;
/* Q = I */
if (Qp) {
*Qp = Q = Matrix_Alloc(nc, nc);
if (!Q) {
errormsg1("DomLeftHermite", "outofmem", "out of memory space");
value_clear(tmp);
return;
}
Vector_Set(Q->p_Init,0,nc*nc); /* zero's */
for (i=0;i<nc;i++) /* with diagonal of 1's */
value_set_si(Q->p[i][i],1);
}
else Q=(Matrix *)0;
rank = hermite(HT,U,Q);
/* H = HT transpose */
*Hp = H = Matrix_Alloc(nr,nc);
if (!H) {
errormsg1("DomLeftHermite", "outofmem", "out of memory space");
value_clear(tmp);
return;
}
for (i=0; i<nr; i++)
for (j=0;j<nc;j++)
value_assign(H->p[i][j],HT->p[j][i]);
Matrix_Free(HT);
/* Transpose U */
if (U) {
for (i=0; i<nc; i++) {
for (j=i+1; j<nc; j++) {
value_assign(tmp,U->p[i][j]);
value_assign(U->p[i][j],U->p[j][i] );
value_assign(U->p[j][i],tmp);
}
}
}
value_clear(tmp);
} /* left_hermite */
static ex hermite_deriv(const ex& n, const ex & x, unsigned deriv_param)
{
if (deriv_param == 0)
throw std::runtime_error("derivative w.r.t. to the index is not supported yet");
return _ex2 * n * hermite(n-1, x).hold();
}
virtual coord_type eval(const coord_type& x) const
{ return coord_type(hermite(a,b,x[1]));}
