genu
extremes.cc: if (kc->simugrid) {
extremes.cc: if (kc->genuine_dim[d]) {
extremes.cc: if ((next = ((min[d] > kc->x[XENDD[d]]) ||
extremes.cc: (max[d] < kc->x[XSTARTD[d]])))) { break;}
extremes.cc: if (min[d] < kc->x[XSTARTD[d]]) {start[d]=0;}
extremes.cc: else start[d] = (int) ((min[d] - kc->x[XSTARTD[d]]) /
extremes.cc: kc->x[XSTEPD[d]]);
extremes.cc: end[d] = (int) ((max[d] - kc->x[XSTARTD[d]]) /
extremes.cc: kc->x[XSTEPD[d]]);
extremes.cc: coord[kc->idx[d]] = startcoord[d] =
extremes.cc: kc->x[XSTARTD[d]] +(double)start[d] * kc->x[XSTEPD[d]];
extremes.cc: coord[kc->idx[d]] += kc->x[XSTEPD[d]];
extremes.cc: coord[kc->idx[d]] = startcoord[d];
extremes.cc: coord[kc->idx[d]] += kc->x[XSTEPD[d]];
extremes.cc: for (d=0; d<dim; d++) y[d] = kc->x[j++];
Hyperfcts.cc: // printf("get: %s %d %f\n", CovList[kc->nr].name, instance, kc->param[KAPPA]);
Hyperfcts.cc: if (kc->nr == EXPONENTIAL) {
Hyperfcts.cc: } else if (kc->nr == CAUCHY) {
Hyperfcts.cc: if (kc->nr == GENERALISEDCAUCHY || kc->nr==STABLE) {
Hyperfcts.cc: } else if (kc->nr == WHITTLEMATERN) {
Hyperfcts.cc: if (kc->param[KAPPA] <= thres[0]) {
Hyperfcts.cc: } else if (kc->param[KAPPA] <= thres[1]) {
Hyperfcts.cc: param = kc->param;
Hyperfcts.cc: nsub= (int) (kc->param[HYPERNR]);
Hyperfcts.cc: store[v] = kc->aniso[0];
Hyperfcts.cc: kc->aniso[0] = d;
Hyperfcts.cc: if ((kc->nr == GENERALISEDCAUCHY && kc->param[KAPPA] <= 1.0) ||
Hyperfcts.cc: (kc->nr == STABLE && kc->param[KAPPA] <= 1.0) ||
Hyperfcts.cc: (kc->nr == EXPONENTIAL) ||
Hyperfcts.cc: (kc->nr == WHITTLEMATERN && kc->param[KAPPA] <= 0.5)) {
Hyperfcts.cc: } else if (kc->nr == BROWNIAN) {
Hyperfcts.cc: q[INTRINSIC_RAWR] = (kc->truetimespacedim <= 2
Hyperfcts.cc: ? ((kc->param[KAPPA] <= 1.5) ? 1.0 : 2.0)
Hyperfcts.cc: : ((kc->param[KAPPA] <= 1.0) ? 1.0 : 2.0));
Hyperfcts.cc: kc->param[INTRINSIC_RAWR] *= 2.0;
Hyperfcts.cc: param = kc->param;
Hyperfcts.cc: nsub= (int) (kc->param[HYPERNR]);
Hyperfcts.cc: store[v] = kc->aniso[0];
Hyperfcts.cc: kc->aniso[0] = d;
Hyperfcts.cc: if (v<nsub && CovList[kc->nr].variogram && kc->op)
Hyperfcts.cc: param = kc->param;
Hyperfcts.cc: if (kc->genuine_last_dimension)
Hyperfcts.cc: nsub= (int) (kc->param[HYPERNR]);
Hyperfcts.cc: endfor = ANISO + kc->dim * kc->dim - 1;
Hyperfcts.cc: if (kc->param[i]!=0.0) {
Hyperfcts.cc: kc->param[i], 1 - (ANISO - i), v); // i - ANISO + 1 gibt
MPP.cc: if ((kc->method==AdditiveMpp) && kc->left
MPP.cc: && (kc->param[VARIANCE]>0)) {
MPP.cc: assert(kc->nr>=0 && kc->nr<currentNrCov);
MPP.cc: cov = &(CovList[kc->nr]);
MPP.cc: if (key->Time && !kc->genuine_last_dimension &&
MPP.cc: if ((error=cov->check(kc->param, kc->truetimespacedim,
MPP.cc: if ((v<key->ncov-1 && kc->op)) {
MPP.cc: kc->left=false;
MPP.cc: timespacedim = kc->truetimespacedim;
MPP.cc: if (kc->simugrid) {
MPP.cc: s->min[kc->idx[d]] = kc->x[XSTARTD[d]];
MPP.cc: s->length[kc->idx[d]]= kc->x[XSTEPD[d]] * (double) (key->length[d] - 1);
MPP.cc: if (kc->x[ix+d] < s->min[d]) s->min[d] = kc->x[ix+d];
MPP.cc: if (kc->x[ix+d] > max[d]) max[d] = kc->x[ix+d];
MPP.cc: CovList[kc->nr].add_mpp_scl(s, timespacedim, kc->param);
MPP.cc: s->MppFct = CovList[kc->nr].add_mpp_rnd;
MPP.cc: factor = sqrt(kc->param[VARIANCE] /
MPP.cc: lambda = kc->param[VARIANCE] * s->effectivearea;
MPP.cc: timespacedim = kc->simugrid ? key->timespacedim : kc->truetimespacedim;
MPP.cc: if (kc->simugrid) {
MPP.cc: if (kc->genuinedim[d]) {
MPP.cc: if (min[d]< kc->x[XSTARTD[d]]) {start[d]=0;}
MPP.cc: else start[d] = (int) ((min[d] - kc->x[XSTARTD[d]]) /
MPP.cc: kc->x[XSTEPD[d]]);
MPP.cc: end[d] = 1 + (int) ((max[d] - kc->x[XSTARTD[d]]) /
MPP.cc: kc->x[XSTEPD[d]]);
MPP.cc: coord[kc->idx[d]] = startcoord[d] =
MPP.cc: kc->x[XSTARTD[d]] + (double) start[d] * kc->x[XSTEPD[d]];
MPP.cc: coord[kc->idx[d]] += kc->x[XSTEPD[d]];
MPP.cc: coord[kc->idx[d]] = startcoord[d];
MPP.cc: coord[kc->idx[d]] += kc->x[XSTEPD[d]];
MPP.cc: for (d=0; d<timespacedim; d++, j++) y[d] = kc->x[j];
RFcircembed.cc: dim = kc->truetimespacedim;
RFcircembed.cc: GetCornersOfGrid(key, dim, kc->aniso, sx);
RFcircembed.cc: dummy = key->x[d][XSTEP] * (double) (key->length[d] - 1) * kc->aniso[0];
RFcircembed.cc:// printf("** %d\n", kc->nr);
RFcircembed.cc: memcpy(&(sc->param[ANISO]), &(kc->param[ANISO]), sizeof(double) * n_aniso);
RFcircembed.cc: err = GetOrthogonalUnitExtensions(kc->aniso, key->timespacedim, grid_ext);
RFgetNset.cc: SET_VECTOR_ELT(submodel[i],subi++, mkString(METHODNAMES[kc->method]));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, ScalarInteger(kc->dim));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, ScalarInteger(kc->truetimespacedim));
RFgetNset.cc: Int(kc->length, kc->simugrid ? kc->dim : 0, MAX_INT));
RFgetNset.cc: Int(kc->idx, kc->simugrid ? kc->dim :0, MAX_INT));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, mkString(CovList[kc->nr].name));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, mkString(OP_SIGN[kc->op]));
RFgetNset.cc: Logi(kc->genuine_dim, kc->simugrid ? kc->dim : 0, MAX_INT));
RFgetNset.cc: ScalarLogical(kc->genuine_last_dimension));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, ScalarLogical(kc->simugrid));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, ScalarLogical(!kc->left));
RFgetNset.cc: : Num(kc->param, totalparam, MAX_INT));
RFgetNset.cc: SET_VECTOR_ELT(submodel[i], subi++, (kc->dim<=0) ? allocVector(VECSXP, 0)
RFgetNset.cc: : Mat(kc->aniso, kc->dim, // kc->truetimespacedim
RFgetNset.cc: kc->dim, MAX_INT)
RFgetNset.cc: if (kc->x == NULL)
RFgetNset.cc: Mat(kc->x, kc->simugrid ? 3 : totalpoints,
RFgetNset.cc: kc->truetimespacedim, MAX_INT));
RFhyperplan.cc: optdim=2; // falls dies gelockert wird, so kc->idx[d] nicht vergessen!
RFhyperplan.cc: if (kc->method==Hyperplane && kc->left) {
RFhyperplan.cc: cov = &(CovList[kc->nr]);
RFhyperplan.cc: assert(kc->nr>=0 && kc->nr<currentNrCov);
RFhyperplan.cc: assert(kc->param[VARIANCE] >= 0.0);
RFhyperplan.cc: if ((key->ncov>v+1 && kc->op) ||
RFhyperplan.cc: timespacedim = kc->truetimespacedim;
RFhyperplan.cc: v += (int) kc->param[HYPERNR];
RFhyperplan.cc: if ((error = cov->check(kc->param, timespacedim, Hyperplane))
RFhyperplan.cc: kc->left = false;
RFhyperplan.cc: timespacedim = kc->truetimespacedim;
RFhyperplan.cc: GetCenterAndDiameter(key, kc->simugrid, timespacedim, kc->truetimespacedim,
RFhyperplan.cc: kc->x, kc->aniso, s->center, s->rx, &(s->radius));
RFhyperplan.cc: for (d=0; d<kc->truetimespacedim; d++) s->rx[d] *= 0.5;
RFhyperplan.cc: timespacedim = kc->truetimespacedim;
RFhyperplan.cc: deltax = kc->x[XSTEPD[0]];
RFhyperplan.cc: deltay = kc->x[XSTEPD[1]];
RFhyperplan.cc: if (kc->simugrid) {
RFhyperplan.cc: for (gy=kc->x[XSTARTD[1]], resindex=j=0; j<key->length[1]; j++) {
RFhyperplan.cc: for (gx= kc->x[XSTARTD[0]], i=0; i<key->length[0]; i++,
RFhyperplan.cc: if ((cell=determine_cell(kc->x[j], kc->x[j+1], hx, hy, hr,
RFnugget.cc:// printf("nugget %d %d %d %s \n", v, kc->nr, key->ncov, CovList[kc->nr].name);
RFnugget.cc: assert((kc->nr >= 0) && (kc->nr < currentNrCov));
RFnugget.cc: assert(kc->param[VARIANCE] >= 0.0);
RFnugget.cc: cov = &(CovList[kc->nr]);
RFnugget.cc: if ((kc->method==Nugget) && (kc->left)) {
RFnugget.cc: quotient = kc->param[nonzero_pos]/first->param[nonzero_pos];
RFnugget.cc: equal &= fabs(first->param[w] * quotient - kc->param[w]) <
RFnugget.cc: (fabs(kc->param[w]) + 1.0*(kc->param[w]==0.0))
RFnugget.cc: kc->left = false;
RFnugget.cc: s->simple = key->timespacedim == kc->truetimespacedim;
RFnugget.cc: s->simugrid = kc->simugrid;
RFnugget.cc: if (kc->simugrid) {
RFnugget.cc: s->diag[d] = kc->param[ANISO + i];
RFnugget.cc: ordering(kc->x, key->totalpoints, kc->truetimespacedim, pos);
RFnugget.cc: if (equal(oldpos, pos[i], kc->x, kc->truetimespacedim))
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: // printf("%d %d %d %d\n", v, kc->method, Method, (int) kc->left);
RFsimu.cc: if (kc->method==Method && kc->left) {
RFsimu.cc: assert((kc->nr >= 0) && (kc->nr < currentNrCov));
RFsimu.cc: assert(kc->param[VARIANCE] >= 0.0);
RFsimu.cc: error = cov->check(kc->param, kc->truetimespacedim, Method);
RFsimu.cc: (int) kc->param[HYPERNR] : 0;
RFsimu.cc: kc->left = false;
RFsimu.cc: kc->left = false;
RFsimu.cc: if (kc->simugrid) {
RFsimu.cc: kc->length[d] = kc->genuine_dim[d] ? key->length[d] : 1;
RFsimu.cc:// kc->length[d], kc->genuine_dim[d], key->length[d]);
RFsimu.cc: return Transform2NoGrid(key, kc->aniso, kc->truetimespacedim,
RFsimu.cc: kc->simugrid, &(kc->x));
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: z = fabs(x[0] * kc->aniso[0]);
RFsimu.cc: fct[w1] = kc->param[VARIANCE] * cov->cov(&z, kc->param, dim);
RFsimu.cc: abl[w1] = kc->param[VARIANCE] * cov->derivative(&z, kc->param)
RFsimu.cc: * kc->aniso[0];
RFsimu.cc: snd[w1] = kc->param[VARIANCE] * cov->secondderivt(&z, kc->param)
RFsimu.cc: * kc->aniso[0] * kc->aniso[0];
RFsimu.cc:// cov->secondderivt(&z, kc->param), cov->name, cov->secondderivt);
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: z = fabs(x[0] * kc->aniso[0]);
RFsimu.cc: fct[w] = kc->param[VARIANCE] * cov->cov(&z, kc->param, dim);
RFsimu.cc: abl[w] = kc->param[VARIANCE] * cov->derivative(&z, kc->param)
RFsimu.cc: * kc->aniso[0];
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: var *= kc->param[VARIANCE];
RFsimu.cc: for (k=0; k<kc->truetimespacedim; k++) z[k]=0.0;
RFsimu.cc: for (ani=0, k=0; k<kc->truetimespacedim; k++) {
RFsimu.cc: z[k] += kc->aniso[ani++] * x[j];
RFsimu.cc: zw *= cov->cov(z, kc->param, kc->truetimespacedim);
RFsimu.cc: endfor = kc->truetimespacedim - 1;
RFsimu.cc: nsub = (int) kc->param[HYPERNR];
RFsimu.cc: zw *= cov->cov(z, kc->param, subdim);
RFsimu.cc:// z[0], z[1], z[2], kc->param[VARIANCE],
RFsimu.cc:// kc->param[KAPPA1], kc->param[KAPPA2], kc->param[KAPPA3],
RFsimu.cc:// subdim, cov->name, cov->cov(z, kc->param, subdim), zw);
RFsimu.cc: zw *= cov->cov(z, kc->param, 1 + (int)(cov_type==SPACEISOTROPIC));
RFsimu.cc: if ((v<ncovM1) && (kc->op==0)) break;
RFsimu.cc: //printf("covfct %d %d\n", v, kc->nr);
RFsimu.cc: cov = &(CovList[kc->nr]); /* cov needed in FORMULA for Vario */
RFsimu.cc: nsub = (int) kc->param[HYPERNR];
RFsimu.cc: z[0] = d * kc->aniso[0];
RFsimu.cc:// d, kc->aniso[0]);
RFsimu.cc: zw *= cov->cov(z, kc->param, subdim);
RFsimu.cc: zz = d * kc->aniso[0];
RFsimu.cc: var *= kc->param[VARIANCE];
RFsimu.cc: zw *= cov->cov(&zz, kc->param, 1);
RFsimu.cc: if ((v<ncovM1) && (kc->op==0)) break;
RFsimu.cc:// kc->param[KAPPA], v, covlist[v], kc->nr);
RFsimu.cc:// *x, z[0], z[1], result, d, kc->aniso[0],
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: *equal &= !memcmp(kc->param, ParamList, sizeof(double) * kappasP1);
RFsimu.cc: memcpy(kc->param, ParamList, sizeof(double)* kappasP1);
RFsimu.cc: if (kc->param[VARIANCE]<0.0) return ERRORNEGATIVEVAR;
RFsimu.cc: *equal &= kc->op == op[v];
RFsimu.cc: kc->op = op[v];
RFsimu.cc:// kc->op, false xor false, false xor true, true xor true);
RFsimu.cc: xor (kc->op == 2))
RFsimu.cc: GetNaturalScaling(&(kc->nr), &(kc->param[KAPPA]),
RFsimu.cc: *equal &= !memcmp(&(kc->param[ANISO]), &(param[ANISO]),
RFsimu.cc: memcpy(&(kc->param[ANISO]), &(param[ANISO]), sizeof(double) * pAniso);
RFsimu.cc: GetTrueDim(anisotropy, timespacedim, kc->param, cov->type,
RFsimu.cc: &(kc->genuine_last_dimension),
RFsimu.cc: &(kc->truetimespacedim), kc->aniso);
RFsimu.cc: kc->dim = timespacedim;
RFsimu.cc: if (cov->type==SPACEISOTROPIC && !kc->genuine_last_dimension)
RFsimu.cc: if (kc->truetimespacedim==0) return ERRORTRIVIAL;
RFsimu.cc: error = check_within_range(kc->param, cov, kc->truetimespacedim, NULL);
RFsimu.cc: cov->info(kc->param, &maxdim, &dummy);
RFsimu.cc:// printf("%d %d\n", maxdim, kc->truetimespacedim);
RFsimu.cc: if (maxdim < kc->truetimespacedim) return ERRORCOVNOTALLOWED;
RFsimu.cc: kc->simugrid = // kc->param[ANISO] !!
RFsimu.cc: grid && (!anisotropy || is_diag(&(kc->param[ANISO]), timespacedim));
RFsimu.cc: if (kc->simugrid) {
RFsimu.cc: if ((kc->genuine_dim[d] = param[ANISO + n] != 0.0)) {
RFsimu.cc: kc->idx[d] = ii++;
RFsimu.cc: kc->idx[d] = kc->truetimespacedim + d - ii;
RFsimu.cc: kc->genuine_dim[d] = true;
RFsimu.cc: kc->idx[d] = d;
RFsimu.cc: kc->simugrid = false; // not programmed yet -- save version !!!!!!
RFsimu.cc: error = cov->check(kc->param, kc->truetimespacedim, Nothing);
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc:// memcpy(&(kc->param[ANISO]), &(keycov[v+1].param[ANISO]),
RFsimu.cc: memcpy(&(kc->param[ANISO]), &(keycov[v+1].param[ANISO]),
RFsimu.cc: GetTrueDim(anisotropy, timespacedim, kc->param,
RFsimu.cc: &(kc->genuine_last_dimension), //
RFsimu.cc: &(kc->truetimespacedim), kc->aniso);//
RFsimu.cc: kc->aniso[0] = RF_NAN;
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: v += (int) kc->param[HYPERNR];
RFsimu.cc: if (CovList[kc->nr].cov == nugget && meth!=Nugget && ncov>1 &&
RFsimu.cc: kc->truetimespacedim < timespacedim)) {
RFsimu.cc: key->active &= kc->method == meth;
RFsimu.cc: cov = &(CovList[kc->nr]);
RFsimu.cc: error=cov->check(kc->param, 2, TBM2);
RFsimu.cc: kc->param[TBM2NUM] =
RFsimu.cc: if (GENERAL_PRINTLEVEL > 1 && (kc->param[TBM2NUM]!=0.0))
RFsimu.cc: if (kc->method >= (int) Nothing) {
RFsimu.cc:// printf("kc->method=%d %d %d \n", v, kc->method, (int) Nothing);
RFsimu.cc: if (CovList[kc->nr].type == ISOHYPERMODEL ||
RFsimu.cc: CovList[kc->nr].type == ANISOHYPERMODEL) {
RFsimu.cc: int i, nc = (int) kc->param[HYPERNR];
RFsimu.cc: if (kc->method != key->cov[i].method) {
RFsimu.cc: if (v>0 && op[v-1] && kc->method!=key->cov[v-1].method) {
RFsimu.cc: kc->method==CircEmbedIntrinsic) {
RFsimu.cc: key->ML[v][0] = kc->method;
RFsimu.cc: kc->left = left[v];
RFsimu.cc:// if (kc->left) {
RFsimu.cc:// if (kc->x != NULL) { free(kc->x); kc->x = NULL; }
RFsimu.cc: if (kc->left) {
RFsimu.cc: PRINTF("'%s' not initiated yet\n", CovList[kc->nr].name);
RFsimu.cc: Merr = kc->method;
RFsimu.cc: kc->left = left[w];
RFsimu.cc:// if (kc->left) {
RFsimu.cc: CovList[kc->nr].name);
RFspectral.cc: if ((kc->method==SpectralTBM) && (kc->left)) {
RFspectral.cc: timespacedim = kc->truetimespacedim;
RFspectral.cc: assert((kc->nr >= 0) && (kc->nr < currentNrCov));
RFspectral.cc: assert(kc->param[VARIANCE] >= 0.0);
RFspectral.cc: cov = &(CovList[kc->nr]);
RFspectral.cc: if ((Xerror=check_within_range(kc->param, cov, 2, " (spectral TBM)"))
RFspectral.cc: (Xerror=cov->check(kc->param, timespacedim, SpectralTBM))
RFspectral.cc: if (store_variance == kc->param[VARIANCE]) actcov++;
RFspectral.cc: kc->left=true;
RFspectral.cc: store_variance = kc->param[VARIANCE];
RFspectral.cc: kc->left = false;
RFspectral.cc: assert((kc->truetimespacedim>=1) && (kc->truetimespacedim<=2));
RFspectral.cc: sqrttwodivbyn = sqrt(kc->param[VARIANCE] * 2.0 / (double) SPECTRAL_LINES);
RFspectral.cc: Amp= (s->randomAmplitude[v])(kc->param);
RFspectral.cc: if (kc->simugrid) {
RFspectral.cc:// printf("%d %d \n", d, kc->length[d]);
RFspectral.cc: if (kc->length[d] != 1) {
RFspectral.cc: segt += kc->x[XSTARTD[d]] * cossin[idxcossind];
RFspectral.cc: inc[d] = kc->x[XSTEPD[d]] * cossin[idxcossind++];
RFspectral.cc: if (kc->truetimespacedim==1) {
RFspectral.cc: res[nx] += cos(cp * kc->x[nx] + VV);
RFspectral.cc: } else { // kc->truetimespacedim==2
RFspectral.cc: res[nx] += cos(cp * kc->x[twonx] + sp * kc->x[twonx+1] + VV);
RFtbm.cc: cov = &(CovList[kc->nr]);
RFtbm.cc: z[0] = kc->aniso[0] * x[0];
RFtbm.cc: z[1] = kc->aniso[TBMTIME] * x[1];
RFtbm.cc: if (z[0]==0.0) zw *= cov->cov(&(z[1]), kc->param, dim);
RFtbm.cc: zw *= TBM2integr(kc->nr, z[0], z[1], kc->param, 2, 2);
RFtbm.cc: zw *= kc->param[VARIANCE] * z[0] / r *
RFtbm.cc: (cov->cov_tbm2(&r, kc->param, dim) +
RFtbm.cc: TBM2integr_time(z[0] / r, r, cov->cov, kc->param, dim) );
RFtbm.cc: if (z[0]==0.0) zw *= cov->cov(z, kc->param, 2);
RFtbm.cc: else if (kc->param[TBM2NUM] == 0.0) {
RFtbm.cc: zw *= cov->cov_tbm2(z, kc->param);
RFtbm.cc: zw *= TBM2integr(kc->nr, z[0], z[1], kc->param, 2,
RFtbm.cc: zw *= kc->param[VARIANCE];
RFtbm.cc: cov = &(CovList[kc->nr]);
RFtbm.cc: z = x[0] * kc->aniso[0];
RFtbm.cc: else if (kc->param[TBM2NUM] == 0.0) {
RFtbm.cc: zw = cov->cov_tbm2(&z, kc->param);
RFtbm.cc: zw = TBM2integr(kc->nr, z, 0, kc->param, 2, cov->cov_tbm3 == NULL);
RFtbm.cc: result += kc->param[VARIANCE] * zw;
RFtbm.cc: cov = &(CovList[kc->nr]);
RFtbm.cc: z[0] = kc->aniso[0] * x[0];
RFtbm.cc: z[1] = kc->aniso[TBMTIME] * x[1];
RFtbm.cc: else abl[w] = kc->param[VARIANCE] * kc->aniso[0] * fabs(z[0]) /
RFtbm.cc: r * cov->derivative(&r, kc->param);
RFtbm.cc: zw *= (fct[w] = kc->param[VARIANCE] * cov->cov(&r, kc->param, dim));
RFtbm.cc: abl[w] = kc->param[VARIANCE] *
RFtbm.cc: kc->aniso[0] * cov->derivative(z, kc->param);
RFtbm.cc: zw *= (fct[w] = kc->param[VARIANCE] * cov->cov(z, kc->param, dim));
RFtbm.cc: cov = &(CovList[kc->nr]);
RFtbm.cc: z[0] = x[0] * kc->aniso[0];
RFtbm.cc: return kc->param[VARIANCE] * cov->cov_tbm3(z, kc->param);
RFtbm.cc: if ((kc->method==method) && (kc->left)) {
RFtbm.cc: ce_dim2 |= CovList[kc->nr].type==SPACEISOTROPIC ||
RFtbm.cc: kc->truetimespacedim == 1 + tbm_dim;
RFtbm.cc: while (!ce_dim2 && (++v)<key->ncov && kc->op) {
RFtbm.cc: ce_dim2 |= CovList[kc->nr].type==SPACEISOTROPIC;
RFtbm.cc: quot = kc->param[nonzero_pos] / first->param[nonzero_pos];
RFtbm.cc: if (fabs(first->param[w] * quot - kc->param[w]) >=
RFtbm.cc: (fabs(kc->param[w]) + (double)(kc->param[w]==0.0)) *
RFtbm.cc: if (kc->truetimespacedim > tbm_dim) {
RFtbm.cc: if ((kc->method==method) && (kc->left)) {
RFtbm.cc: cov = &(CovList[kc->nr]);
RFtbm.cc: assert((kc->nr>=0) && (kc->nr<currentNrCov));
RFtbm.cc: assert(kc->param[VARIANCE]>=0.0);
RFtbm.cc: if (v<key->ncov-1 && kc->op) {
RFtbm.cc: kc->left = true;
RFtbm.cc: if ((Xerror=check_within_range(kc->param, cov, tbm_dim + (int) ce_dim2,
RFtbm.cc: Xerror=cov->check(kc->param, tbm_dim + (int) ce_dim2, method);
RFtbm.cc: quot = kc->param[nonzero_pos] / first->param[nonzero_pos];
RFtbm.cc: equal = fabs(first->param[w] * quot - kc->param[w])
RFtbm.cc: < (fabs(kc->param[w]) + (double)(kc->param[w]==0.0)) *
RFtbm.cc: kc->left = true;
RFtbm.cc: memcpy(&(ParamList[cum_nParam[actcov]]), kc->param,
RFtbm.cc: covnr[actcov] = kc->nr;
RFtbm.cc: op[actcov] = kc->op;
RFtbm.cc: if (kc->param[w]!=0.0) {
RFtbm.cc: ParamList[Aniso + 3] = kc->param[lasttimecomponent];
RFtbm.cc: if (kc->param[w] != 0.0) {
RFtbm.cc: if (spacecomponent_found = (kc->param[w]!=0.0)) break;
RFtbm.cc: kc->left=false;
RFtbm.cc: } // kc->left
RFtbm.cc: newadditive = kc->op != 0;