/* Authors Martin Schlather, schlather@math.uni-mannheim.de Copyright (C) 2015 -- 2017 Martin Schlather This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You 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. */ #ifndef RFMachines_H #define RFMachines_H 1 #define LASTi(sys) (sys).last #define CUMXMITi(sys) (sys).cumxdim #define XDIMi(sys) (sys).xdim // OK #define LOGDIMi(sys) (sys).logicaldim #define MAXDIMi(sys) (sys).maxdim #define ISOi(sys) (sys).iso #define DOMi(sys) (sys).dom #define TYPEi(sys) (sys).type #define NRi(sys) (sys).nr #define MODELNR(cov) SYSMODEL(SYSOF(cov)) #define isSetLastSystem(sys) (LASTi((sys)[0]) != UNSET) #define ANYDIM ANYDIMOF(cov) #define SYSTEMS(s) (LASTSYSTEM(s) + 1) #define CALLING SYSOF(cov->calling) #define CALLINGNR SYSMODEL(CALLING) #define PREV PREVSYSOF(cov) #define PREVCUMXOHNE(s) CUMXOHNE(PREV, s) #define PREVCUMXMIT(s) CUMXMIT(PREV, s) #define PREVXDIM(s) XDIM(PREV, s) #define PREVISO(s) ISO(PREV, s) #define PREV_INITIALISEDXX isSetLastSystem(PREVSYSOF(cov)) // #define PREV_INITIALISED (isSetLastSystem(PREVSYSOF(cov)) && XDIM(PREV, 0) != UNSET) // siehe settrafo in op...cc #define CONDPREVISO(s) (PREV_INITIALISED ? PREVISO(s) : ISO_MISMATCH) #define CONDPREVDOM(s) (PREV_INITIALISED ? PREVDOM(s) : DOMAIN_MISMATCH) #define PREVDOM(s) DOM(PREV, s) #define PREVTYPE(s) SYSTYPE(PREV, s) #define PREVLOGDIM(s) LOGDIM(PREV, s) #define PREVTOTALXDIM TOTALXDIM(PREV) #define PREVLASTSYSTEM LASTSYSTEM(PREV) #define PREVSYSTEMS SYSTEMS(PREV) #define PREVRESETLAST RESETLAST(PREV) #define PREVLASTSYS(s) LASTSYS(PREV, s) #define TRAFONR SYSMODEL(PREV) #define GATTER GATTERSYSOF(cov) #define GATTERCUMXOHNE(s) CUMXOHNE(GATTER, s) #define GATTERCUMXMIT(s) CUMXMIT(GATTER, s) #define GATTERXDIM(s) XDIM(GATTER, s) #define GATTERISO(s) ISO(GATTER, s) #define GATTERDOM(s) DOM(GATTER, s) #define GATTERTYPE(s) SYSTYPE(GATTER, s) #define GATTERLOGDIM(s) LOGDIM(GATTER, s) #define GATTERTOTALXDIM TOTALXDIM(GATTER) #define GATTERLASTSYSTEM LASTSYSTEM(GATTER) #define GATTERSYSTEMS SYSTEMS(GATTER) #define GATTERNR SYSMODEL(GATTER) #define OWN SYSOF(cov) #define OWNCUMXOHNE(s) CUMXOHNE(OWN, s) #define OWNCUMXMIT(s) CUMXMIT(OWN, s) #define OWNXDIM(s) XDIM(OWN, s) #define OWNISO(s) ISO(OWN, s) #define OWNDOM(s) DOM(OWN, s) #define CONDOWNISO(s) (PREV_INITIALISED ? OWNISO(s) : ISO_MISMATCH) #define CONDOWNDOM(s) (PREV_INITIALISED ? OWNDOM(s) : DOMAIN_MISMATCH) #define OWNTYPE(s) SYSTYPE(OWN, s) #define OWNLOGDIM(s) LOGDIM(OWN, s) #define OWNMAXDIM(s) MAXDIM(OWN, s) #define OWNTOTALXDIM TOTALXDIM(OWN) #define OWNLASTSYSTEM LASTSYSTEM(OWN) #define OWNSYSTEMS SYSTEMS(OWN) #define OWNRESETLAST RESETLAST(OWN) #define COVNR (SYSMODEL(OWN)) #define VDIM0 cov->vdim[0] #define VDIM1 cov->vdim[1] #define SUB SYSOF(sub) #define SUBCUMXOHNE(s) CUMXOHNE(SUB, s) #define SUBCUMXMIT(s) CUMXMIT(SUB, s) #define SUBXDIM(s) XDIM(SUB, s) #define SUBISO(s) ISO(SUB, s) #define SUBDOM(s) DOM(SUB, s) #define SUBTYPE(s) SYSTYPE(SUB, s) #define SUBLOGDIM(s) LOGDIM(SUB, s) #define SUBMAXDIM(s) MAXDIM(SUB, s) #define SUBTOTALXDIM TOTALXDIM(SUB) #define SUBLASTSYSTEM LASTSYSTEM(SUB) #define SUBSYSTEMS SYSTEMS(SUB) #define SUBNR SYSMODEL(SUB) #define NEXT SYSOF(next) #define NEXTCUMXOHNE(s) CUMXOHNE(NEXT, s) #define NEXTCUMXMIT(s) CUMXMIT(NEXT, s) #define NEXTXDIM(s) XDIM(NEXT, s) #define NEXTISO(s) ISO(NEXT, s) #define NEXTDOM(s) DOM(NEXT, s) #define NEXTTYPE(s) SYSTYPE(NEXT, s) #define NEXTLOGDIM(s) LOGDIM(NEXT, s) #define NEXTMAXDIM(s) MAXDIM(NEXT, s) #define NEXTTOTALXDIM TOTALXDIM(NEXT) #define NEXTLASTSYSTEM LASTSYSTEM(NEXT) #define NEXTSYSTEMS SYSTEMS(NEXT) #define NEXTNR SYSMODEL(NEXT) #define DEFSYS(Cov) DefList[MODELNR(Cov)].systems[(Cov)->variant == UNSET \ ? 0 : (Cov)->variant] #define DEF DEFSYS(cov) #define DEFISO(s) ISO(DEF, s) #define DEFDOM(s) DOM(DEF, s) #define DEFTYPE(s) SYSTYPE(DEF, s) #define DEFMAXDIM(s) MAXDIM(DEF, s) #define DEFSYSTEMS SYSTEMS(DEF) #define DEFLASTSYSTEM LASTSYSTEM(DEF) #define SET_OUT_OF(D) (D)->lpx[GLOBAL.general.set] #define NROW_OUT_OF(D) (D)->nrow[GLOBAL.general.set] #define NCOL_OUT_OF(D) (D)->ncol[GLOBAL.general.set] #define P(IDX) PARAM(cov, IDX) #define PINT(IDX) PARAMINT(cov, IDX) #define PCHAR(IDX) PARAMCHAR(cov, IDX) #define P0(IDX) PARAM0(cov, IDX) #define P0INT(IDX) PARAM0INT(cov, IDX) #define P0CHAR(IDX) PARAM0CHAR(cov, IDX) #define PVEC(IDX) PARAMVEC(cov, IDX) #define PENV(IDX) PARAMENV(cov, IDX) #define PLANG(IDX) PARAMLANG(cov, IDX) #define PLIST(IDX) PARAMLIST(cov, IDX) #define PARAMSEXP(Cov, IDX) ((sexp_type *) (Cov)->px[IDX]) /* kein assert! */ #define PSEXP(IDX) PARAMSEXP(cov, IDX) #define NROW(IDX) cov->nrow[IDX] #define NCOL(IDX) cov->ncol[IDX] #define LP(IDX) LPARAM(cov, IDX) #define LPINT(IDX) LPARAMINT(cov, IDX) #define LP0(IDX) LPARAM0(cov, IDX) #define LP0INT(IDX) LPARAM0INT(cov, IDX) #define LNRC_(I, rc) PLIST(I)->rc[SET_IDX(cov, I)] /* see also Machine*.h */ #define LNROW(IDX) LNRC(IDX, nrow) #define LNCOL(IDX) LNRC(IDX, ncol) #define LPARAMNROW(Cov, IDX) PARAMLIST(Cov, IDX)->nrow[SET_IDX(Cov, IDX)] #define LPARAMNCOL(Cov, IDX) PARAMLIST(Cov, IDX)->ncol[SET_IDX(Cov, IDX)] //#define KAPPASUBisNULL(COV, IDX) COV->kappasub[IDX] == NULL //#define KSUBisNULL(IDX) KAPPASUBisNULL(cov, IDX) #define PARAMFREE(Cov, IDX) if ((Cov)->px[IDX] == NULL) { } else { \ if (DefList[MODELNR(Cov)].kappatype[IDX] < LISTOF) { \ UNCONDFREE((Cov)->px[IDX]); \ } else { \ LIST_DELETE( (listoftype **) ((Cov)->px + IDX)); \ } \ (Cov)->ncol[IDX] = (Cov)->nrow[IDX] = 0; \ } #define PARAMALLOC(Cov, IDX, ROW, COL) { \ int _PARAMsize; \ switch(DefList[MODELNR(Cov)].kappatype[IDX]) { \ case REALSXP : _PARAMsize = sizeof(double); break; \ case INTSXP : _PARAMsize = sizeof(int); break; \ default : \ if ((Cov)->kappasub[IDX]!=NULL && MODELNR((Cov)->kappasub[IDX])==DISTRIBUTION) { \ ERR0("argument value recognized as distribution family although it should not. Maybe the error is caused by a non-existing variable."); \ } else BUG; \ } \ assert((Cov)->px[IDX]==NULL); \ (Cov)->nrow[IDX] = ROW; (Cov)->ncol[IDX] = COL; \ if (((Cov)->px[IDX] = \ (double*) CALLOC((ROW) * (COL), _PARAMsize)) == NULL) { \ XERR(ERRORMEMORYALLOCATION) \ } \ } #define PALLOC(IDX, ROW, COL) PARAMALLOC(cov, IDX, ROW, COL) #define PFREE(IDX) PARAMFREE(cov, IDX) #define PARAMisNULL(Cov, IDX) ((Cov)->px[IDX] == NULL) #define PisNULL(IDX) PARAMisNULL(cov, IDX) #define PARAMtoNULL(Cov, IDX) (Cov)->px[IDX] = NULL #define PtoNULL(IDX) PARAMtoNULL(cov, IDX) #define QALLOC(nr) QcovALLOC(cov, nr) #define QALLOC1(x1) if (cov->q == NULL) { QALLOC(1); cov->q[0] = x1; } #define QALLOC2(x1,x2) if (cov->q == NULL) { QALLOC(2); cov->q[0] = x1; cov->q[1] = x2; } #define QALLOC3(x1,x2,x3) if (cov->q == NULL) { QALLOC(3); cov->q[0] = x1; cov->q[1] = x2; cov->q[2] = x3;} #define QFREE \ if ((cov)->q == NULL) { } else { \ UNCONDFREE((cov)->q); \ (cov)->qlen = 0; \ } #define set_xdim(S, I, V) DEBUG(set_xdim_intern(S, I, V)) #define set_xdim_blank(S, I, V) XDIMi((S)[I])=V // OK #define set_logdim(S, I, V) LOGDIMi((S)[I])=V #define set_nr(S, V) NRi((S)[0])=V #define set_trafo(V) set_nr(PREV, V) #define set_nri(S, I, V) NRi((S)[I])=V #define set_maxdim(S,I,V) MAXDIMi((S)[I])=V #define set_last(S,I,V) LASTi((S)[I])=V #define set_iso(S,I,V) ISOi((S)[I])=V #define set_dom(S,I,V) DOMi((S)[I])=V #define set_type(S,I,V) TYPEi((S)[I])=V #define set_cumxmit(S,I,V) CUMXMITi((S)[I])=V void set_system_type(system_type *sys, Types type); void set_system_domain(system_type *sys, domain_type dom); void set_system(system_type * sys, int idx, int logicaldim, int maxdim, int xdim, Types type, domain_type dom, isotropy_type iso); void set_system(system_type * sys, int idx, int logicaldim, int maxdim, int xdim, Types type, domain_type dom, isotropy_type iso, bool check_unset); void set_both_systems(model *cov, int dim, Types type); sortsofparam SortOf(model *cov,int k, int row, int col, sort_origin origin); int total_logicaldim(system_type * sys); void set_xdim_intern(system_type *sys, int i, int value); #define LocLoc(loc) ((loc) != NULL ? (loc)[GLOBAL.general.set % (loc)[0]->len]\ : NULL) #define Loc(cov) ((cov)->ownloc!=NULL ? LocLoc((cov)->ownloc) : \ LocLoc((cov)->prevloc)) #define PLoc(cov) ((cov)->ownloc != NULL ? (cov)->ownloc : (cov)->prevloc) #define PrevLoc(cov) \ ((cov)->prevloc == NULL ? NULL : \ (cov)->prevloc[GLOBAL.general.set % (cov)->prevloc[0]->len]) #define OwnLoc(cov) ((cov)->ownloc == NULL ? NULL : \ (cov)->ownloc[GLOBAL.general.set % (cov)->ownloc[0]->len]) #define Getgrid(cov) (PLoc(cov) != NULL ? Loc(cov)->grid : false) #define GetTime(cov) (PLoc(cov) != NULL ? Loc(cov)->Time : false) #define GetLoctsdim(cov) (PLoc(cov) != NULL ? Loc(cov)->timespacedim : 0) #define GetLocspatialdim(cov) (PLoc(cov) != NULL ? Loc(cov)->spatialdim : 0) #define Gettotalpoints(cov) (PLoc(cov) != NULL ? Loc(cov)->totalpoints : 0) #define Getspatialpoints(cov) (PLoc(cov) != NULL ? Loc(cov)->spatialtotalpoints\ : 0) #define Getcaniso(cov) (PLoc(cov) != NULL ? Loc(cov)->caniso : NULL) #define Getxgr(cov) (PLoc(cov) != NULL ? Loc(cov)->xgr : NULL) #define Getx(cov) (PLoc(cov) != NULL ? Loc(cov)->x : NULL) #define DistancesGiven(cov) (PLoc(cov) != NULL ? Loc(cov)->distances : false) #define GET_LOC_SETS(cov) (PLoc(cov) != NULL ? PLoc(cov)[0]->len : 0) #define DEBUG(A) A ////////////////////////////////////////////////////////////////////// // CHECKING ////////////////////////////////////////////////////////////////////// #define ASSERT_GATTER(Cov) assert(TrafoOK(Cov, __FILE__, __LINE__)) #define ASSERT_CHECKED(Cov) assert((Cov)->checked) #define ASSERT_LOC_GIVEN \ if (loc != NULL) { } else {PMI(cov); LOC_NOT_INITIALISED;} #define ASSERT_CARTESIAN if (isCartesian(OWN)) {} else RETURN_ERR(ERRORCARTESIAN) #define ASSERT_QUASIONESYSTEM if (QuasiOneSystem(cov)) { } else BUG; #define ASSERT_ONESYSTEM { \ if (OWNLASTSYSTEM != 0 && (OWNLASTSYSTEM != 1 || \ !equalsIsotropic(OWNISO(0)) \ /* || !equalsIsotropic(OWNISO(1)) */ )) BUG;} #define ASSERT_UNREDUCED {assert(OWNXDIM(0) == OWNLOGDIM(0) && PREVXDIM(0) == OWNLOGDIM(0));} #define ASSERT_GAUSS_METHOD(METHOD) DEBUGINFO; \ if(!hasGaussMethodFrame(cov) || cov->method != (METHOD)) { \ SERR4("Gaussian field for '%.50s' only possible with '%.50s' as method. Got frame '%.50s' and method '%.50s'.", \ NICK(cov), \ DefList[(METHOD) == RandomCoin ? RANDOMCOIN_USER : \ gaussmethod[METHOD] - \ DefList[gaussmethod[METHOD]].internal].nick, \ TYPE_NAMES[cov->frame], \ gaussmethod[cov->method] <= 0 ? "MISMATCH" :\ DefList[cov->method == RandomCoin ? RANDOMCOIN_USER : \ gaussmethod[cov->method] - \ DefList[gaussmethod[cov->method]].internal].nick \ ) } #endif