Main Page | Directories | File List | File Members | Related Pages

# Classes.c

Go to the documentation of this file.

    00001
    00009 #include "party.h"
    00010
    00011 SEXP
    00012     PL2_expectationSym,
    00013     PL2_covarianceSym,
    00014     PL2_linearstatisticSym,
    00015     PL2_expcovinfSym,
    00016     PL2_expcovinfssSym,
    00017     PL2_sumweightsSym,
    00018     PL2_dimensionSym,
    00019     PL2_MPinvSym,
    00020     PL2_rankSym,
    00021     PL2_svdSym,
    00022     PL2_svdmemSym,
    00023     PL2_methodSym,
    00024     PL2_jobuSym,
    00025     PL2_jobvSym,
    00026     PL2_uSym,
    00027     PL2_vSym,
    00028     PL2_sSym,
    00029     PL2_pSym,
    00030     PL2_teststatSym,
    00031     PL2_pvalueSym,
    00032     PL2_tolSym,
    00033     PL2_maxptsSym,
    00034     PL2_absepsSym,
    00035     PL2_relepsSym,
    00036     PL2_minprobSym,
    00037     PL2_minsplitSym,
    00038     PL2_minbucketSym,
    00039     PL2_variablesSym,
    00040     PL2_transformationsSym,
    00041     PL2_is_nominalSym,
    00042     PL2_is_ordinalSym,
    00043     PL2_is_censoredSym,
    00044     PL2_orderingSym,
    00045     PL2_levelsSym,
    00046     PL2_scoresSym,
    00047     PL2_has_missingsSym,
    00048     PL2_whichNASym,
    00049     PL2_jointtransfSym,
    00050     PL2_nobsSym,
    00051     PL2_ninputsSym,
    00052     PL2_linexpcov2sampleSym,
    00053     PL2_weightsSym,
    00054     PL2_varmemorySym,
    00055     PL2_varMmemorySym,
    00056     PL2_MscorematricesSym,
    00057     PL2_splitstatisticsSym,
    00058     PL2_savesplitstatsSym,
    00059     PL2_responsesSym,
    00060     PL2_inputsSym,
    00061     PL2_testtypeSym,
    00062     PL2_nresampleSym,
    00063     PL2_varctrlSym,
    00064     PL2_splitctrlSym,
    00065     PL2_gtctrlSym,
    00066     PL2_mincriterionSym,
    00067     PL2_maxsurrogateSym,
    00068     PL2_randomsplitsSym,
    00069     PL2_mtrySym,
    00070     PL2_dontuseSym,
    00071     PL2_dontusetmpSym,
    00072     PL2_stumpSym,
    00073     PL2_maxdepthSym,
    00074     PL2_tgctrlSym,
    00075     PL2_ntreeSym,
    00076     PL2_replaceSym,
    00077     PL2_fractionSym;
    00078
    00079 SEXP party_init(void) {
    00080     PL2_expectationSym = install("expectation");
    00081     PL2_covarianceSym = install("covariance");
    00082     PL2_linearstatisticSym = install("linearstatistic");
    00083     PL2_expcovinfSym = install("expcovinf");
    00084     PL2_expcovinfssSym = install("expcovinfss");
    00085     PL2_sumweightsSym = install("sumweights");
    00086     PL2_dimensionSym = install("dimension");
    00087     PL2_MPinvSym = install("MPinv");
    00088     PL2_rankSym = install("rank");
    00089     PL2_svdSym = install("svd");
    00090     PL2_svdmemSym = install("svdmem");
    00091     PL2_methodSym = install("method");
    00092     PL2_jobuSym = install("jobu");
    00093     PL2_jobvSym = install("jobv");
    00094     PL2_uSym = install("u");
    00095     PL2_vSym = install("v");
    00096     PL2_sSym = install("s");
    00097     PL2_pSym = install("p");
    00098     PL2_teststatSym = install("teststat");
    00099     PL2_pvalueSym = install("pvalue");
    00100     PL2_tolSym = install("tol");
    00101     PL2_maxptsSym = install("maxpts");
    00102     PL2_absepsSym = install("abseps");
    00103     PL2_relepsSym = install("releps");
    00104     PL2_minsplitSym = install("minsplit");
    00105     PL2_minprobSym = install("minprob");
    00106     PL2_minbucketSym = install("minbucket");
    00107     PL2_variablesSym = install("variables");
    00108     PL2_transformationsSym = install("transformations");
    00109     PL2_is_nominalSym = install("is_nominal");
    00110     PL2_is_ordinalSym = install("is_ordinal");
    00111     PL2_is_censoredSym = install("is_censored");
    00112     PL2_orderingSym = install("ordering");
    00113     PL2_levelsSym = install("levels");
    00114     PL2_scoresSym = install("scores");
    00115     PL2_has_missingsSym = install("has_missings");
    00116     PL2_whichNASym = install("whichNA");
    00117     PL2_jointtransfSym = install("jointtransf");
    00118     PL2_nobsSym = install("nobs");
    00119     PL2_ninputsSym = install("ninputs");
    00120     PL2_linexpcov2sampleSym = install("linexpcov2sample");
    00121     PL2_weightsSym = install("weights");
    00122     PL2_varmemorySym = install("varmemory");
    00123     PL2_varMmemorySym = install("varMmemory");
    00124     PL2_MscorematricesSym = install("Mscorematrices");
    00125     PL2_splitstatisticsSym = install("splitstatistics");
    00126     PL2_savesplitstatsSym = install("savesplitstats");
    00127     PL2_responsesSym = install("responses");
    00128     PL2_inputsSym = install("inputs");
    00129     PL2_testtypeSym = install("testtype");
    00130     PL2_nresampleSym = install("nresample");
    00131     PL2_varctrlSym = install("varctrl");
    00132     PL2_splitctrlSym = install("splitctrl");
    00133     PL2_gtctrlSym = install("gtctrl");
    00134     PL2_mincriterionSym = install("mincriterion");
    00135     PL2_maxsurrogateSym = install("maxsurrogate");
    00136     PL2_randomsplitsSym = install("randomsplits");
    00137     PL2_mtrySym = install("mtry");
    00138     PL2_dontuseSym = install("dontuse");
    00139     PL2_dontusetmpSym = install("dontusetmp");
    00140     PL2_stumpSym = install("stump");
    00141     PL2_maxdepthSym = install("maxdepth");
    00142     PL2_tgctrlSym = install("tgctrl");
    00143     PL2_ntreeSym = install("ntree"),
    00144     PL2_replaceSym = install("replace"),
    00145     PL2_fractionSym = install("fraction");
    00146     return(R_NilValue);
    00147 }
    00148
    00149 /* accessor functions */
    00150
    00151 int get_dimension(SEXP object) {
    00152     return(INTEGER(GET_SLOT(object, PL2_dimensionSym))[0]);
    00153 }
    00154
    00155 int get_teststat(SEXP object) {
    00156     return(INTEGER(GET_SLOT(object, PL2_teststatSym))[0]);
    00157 }
    00158
    00159 int get_pvalue(SEXP object) {
    00160     return(INTEGER(GET_SLOT(object, PL2_pvalueSym))[0]);
    00161 }
    00162
    00163 double get_tol(SEXP object) {
    00164     return(REAL(GET_SLOT(object, PL2_tolSym))[0]);
    00165 }
    00166
    00167 int get_maxpts(SEXP object) {
    00168     return(INTEGER(GET_SLOT(object, PL2_maxptsSym))[0]);
    00169 }
    00170
    00171 double get_abseps(SEXP object) {
    00172     return(REAL(GET_SLOT(object, PL2_absepsSym))[0]);
    00173 }
    00174
    00175 double get_releps(SEXP object) {
    00176     return(REAL(GET_SLOT(object, PL2_relepsSym))[0]);
    00177 }
    00178
    00179 double get_minsplit(SEXP object) {
    00180     return(REAL(GET_SLOT(object, PL2_minsplitSym))[0]);
    00181 }
    00182
    00183 double get_minprob(SEXP object) {
    00184     return(REAL(GET_SLOT(object, PL2_minprobSym))[0]);
    00185 }
    00186
    00187 double get_minbucket(SEXP object) {
    00188     return(REAL(GET_SLOT(object, PL2_minbucketSym))[0]);
    00189 }
    00190
    00191 SEXP get_transformation(SEXP object, int variable) {
    00192     return(VECTOR_ELT(
    00193                GET_SLOT(object, PL2_transformationsSym),
    00194                variable - 1));
    00195 }
    00196
    00197 SEXP get_jointtransf(SEXP object) {
    00198     return(GET_SLOT(object, PL2_jointtransfSym));
    00199 }
    00200
    00201 SEXP get_variable(SEXP object, int variable) {
    00202     return(VECTOR_ELT(
    00203                GET_SLOT(object, PL2_variablesSym),
    00204                variable - 1));
    00205 }
    00206
    00207 int is_nominal(SEXP object, int variable) {
    00208     return(INTEGER(GET_SLOT(object, PL2_is_nominalSym))[variable - 1]);
    00209 }
    00210
    00211 int is_ordinal(SEXP object, int variable) {
    00212     return(INTEGER(GET_SLOT(object, PL2_is_ordinalSym))[variable - 1]);
    00213 }
    00214
    00215 int is_censored(SEXP object, int variable) {
    00216     return(INTEGER(GET_SLOT(object, PL2_is_censoredSym))[variable - 1]);
    00217 }
    00218
    00219 int has_missings(SEXP object, int variable) {
    00220     return(INTEGER(GET_SLOT(object, PL2_has_missingsSym))[variable - 1]);
    00221 }
    00222
    00223 SEXP get_ordering(SEXP object, int variable) {
    00224     if (!is_nominal(object, variable)) {
    00225         return(VECTOR_ELT(
    00226                GET_SLOT(object, PL2_orderingSym),
    00227                variable - 1));
    00228     } else {
    00229         error("Variable %d is not ordered", variable);
    00230         return(R_NilValue);
    00231     }
    00232 }
    00233
    00234 SEXP get_levels(SEXP object, int variable) {
    00235     if (is_nominal(object, variable) ||
    00236         is_ordinal(object, variable)) {
    00237         return(VECTOR_ELT(
    00238                GET_SLOT(object, PL2_levelsSym),
    00239                variable - 1));
    00240     } else {
    00241         error("Variable %d is not an (ordered) factor", variable);
    00242         return(R_NilValue);
    00243     }
    00244 }
    00245
    00246 SEXP get_scores(SEXP object, int variable) {
    00247     if (is_ordinal(object, variable)) {
    00248         return(VECTOR_ELT(
    00249                GET_SLOT(object, PL2_scoresSym),
    00250                variable - 1));
    00251     } else {
    00252         error("Variable %d is not an ordered factor", variable);
    00253         return(R_NilValue);
    00254     }
    00255 }
    00256
    00257 SEXP get_missings(SEXP object, int variable) {
    00258     if (has_missings(object, variable)) {
    00259         return(VECTOR_ELT(
    00260                GET_SLOT(object, PL2_whichNASym),
    00261                variable - 1));
    00262     } else {
    00263         error("Variable %d has no missing values", variable);
    00264         return(R_NilValue);
    00265     }
    00266 }
    00267
    00268 SEXP get_varmemory(SEXP object, int variable) {
    00269     return(VECTOR_ELT(GET_SLOT(object, PL2_varmemorySym),
    00270                       variable - 1));
    00271 }
    00272
    00273 SEXP get_varMmemory(SEXP object, int variable) {
    00274     return(VECTOR_ELT(GET_SLOT(object, PL2_varMmemorySym),
    00275                       variable - 1));
    00276 }
    00277
    00278 SEXP get_Mscorematrix(SEXP object, int variable) {
    00279     return(VECTOR_ELT(GET_SLOT(object, PL2_MscorematricesSym),
    00280                       variable - 1));
    00281 }
    00282
    00283 int get_savesplitstats(SEXP object) {
    00284     return(INTEGER(GET_SLOT(object, PL2_savesplitstatsSym))[0]);
    00285 }
    00286
    00287 SEXP get_splitstatistics(SEXP object) {
    00288     return(GET_SLOT(object, PL2_splitstatisticsSym));
    00289 }
    00290
    00291 int get_nobs(SEXP object) {
    00292     return(INTEGER(GET_SLOT(object, PL2_nobsSym))[0]);
    00293 }
    00294
    00295 int get_ninputs(SEXP object) {
    00296     return(INTEGER(GET_SLOT(object, PL2_ninputsSym))[0]);
    00297 }
    00298
    00299 SEXP get_weights(SEXP object, int variable) {
    00300     return(VECTOR_ELT(GET_SLOT(object, PL2_weightsSym), variable - 1));
    00301 }
    00302
    00303 int get_testtype(SEXP object) {
    00304     return(INTEGER(GET_SLOT(object, PL2_testtypeSym))[0]);
    00305 }
    00306
    00307 int get_nresample(SEXP object) {
    00308     return(INTEGER(GET_SLOT(object, PL2_nresampleSym))[0]);
    00309 }
    00310
    00311 SEXP get_varctrl(SEXP object) {
    00312     return(GET_SLOT(object, PL2_varctrlSym));
    00313 }
    00314
    00315 SEXP get_splitctrl(SEXP object) {
    00316     return(GET_SLOT(object, PL2_splitctrlSym));
    00317 }
    00318
    00319 SEXP get_gtctrl(SEXP object) {
    00320     return(GET_SLOT(object, PL2_gtctrlSym));
    00321 }
    00322
    00323 SEXP get_tgctrl(SEXP object) {
    00324     return(GET_SLOT(object, PL2_tgctrlSym));
    00325 }
    00326
    00327 double get_mincriterion(SEXP object) {
    00328     return(REAL(GET_SLOT(object, PL2_mincriterionSym))[0]);
    00329 }
    00330
    00331 int get_maxsurrogate(SEXP object) {
    00332     return(INTEGER(GET_SLOT(object, PL2_maxsurrogateSym))[0]);
    00333 }
    00334
    00335 int get_randomsplits(SEXP object) {
    00336     return(INTEGER(GET_SLOT(object, PL2_randomsplitsSym))[0]);
    00337 }
    00338
    00339 int get_mtry(SEXP object) {
    00340     return(INTEGER(GET_SLOT(object, PL2_mtrySym))[0]);
    00341 }
    00342
    00343 SEXP get_dontuse(SEXP object) {
    00344     return(GET_SLOT(object, PL2_dontuseSym));
    00345 }
    00346
    00347 SEXP get_dontusetmp(SEXP object) {
    00348     return(GET_SLOT(object, PL2_dontusetmpSym));
    00349 }
    00350
    00351 int get_stump(SEXP object) {
    00352     return(INTEGER(GET_SLOT(object, PL2_stumpSym))[0]);
    00353 }
    00354
    00355 int check_depth(SEXP object, int depth) {
    00356     int maxdepth;
    00357     maxdepth = INTEGER(GET_SLOT(object, PL2_maxdepthSym))[0];
    00358     if (maxdepth == 0) return(1);
    00359     if (maxdepth < 1) error("maxdepth is less than one");
    00360     return(depth <= maxdepth);
    00361 }
    00362
    00363 int get_ntree(SEXP object) {
    00364     return(INTEGER(GET_SLOT(object, PL2_ntreeSym))[0]);
    00365 }
    00366
    00367 int get_replace(SEXP object) {
    00368     return(INTEGER(GET_SLOT(object, PL2_replaceSym))[0]);
    00369 }
    00370
    00371 double get_fraction(SEXP object) {
    00372     return(REAL(GET_SLOT(object, PL2_fractionSym))[0]);
    00373 }