full.ct {cna} | R Documentation |

The function `full.ct`

generates a `configTable`

with all logically possible value configurations of the factors defined in the input `x`

. It is more flexible than `allCombs`

.
`x`

can be a `configTable`

, a data frame, an integer, a list specifying the factors' value ranges, or a character vector featuring all admissible factor values.

full.ct(x, ...) ## Default S3 method: full.ct(x, type = "auto", cond = NULL, ...) ## S3 method for class 'configTable' full.ct(x, cond = NULL, ...) ## S3 method for class 'cti' full.ct(x, cond = NULL, ...)

`x` |
A |

`type` |
Character vector specifying the type of |

`cond` |
Optional character vector containing conditions in the syntax of msc, asf or csf. If it is not |

`...` |
Further arguments passed to methods. |

`full.ct`

generates all logically possible value configurations of the factors defined in `x`

, which can either be a character vector or an integer or a list or a data frame or a matrix.

If

`x`

is a character vector, it can be a condition of any of the three types of conditions,*boolean*,*atomic*or*complex*(see`condition`

).`x`

must contain at least one factor. Factor names and admissible values are guessed from the Boolean formulas. If`x`

contains multi-value factors, only those values are considered admissible that are explicitly contained in`x`

. Accordingly, in case of multi-value factors,`full.ct`

should be given the relevant factor definitions by means of a list (see below).If

`x`

is an integer and`<=26`

, the output will be a logically complete configuration table of type`"cs"`

with`x`

factors. The first`x`

capital letters of the alphabet will be used as the names of the factors.If

`x`

is a list,`x`

is expected to have named elements each of which provides the factor names with corresponding vectors enumerating their admissible values (i.e. their value ranges). These values must be non-negative integers.If

`x`

is a`configTable`

, data frame, or matrix,`colnames(x)`

are interpreted as factor names and the rows as enumerating the admissible values (i.e. as value ranges). If`x`

is a data frame or a matrix,`x`

is first converted to a`configTable`

(the function`configTable`

is called with`type`

as specified in`full.ct`

), and the`configTable`

method of`full.ct`

is then applied to the result. The`configTable`

method uses all factors and factor values occurring in the`configTable`

. If`x`

is of type`"fs"`

, 0 and 1 are taken as the admissible values.

If not all factors specified in `x`

are of interest but only those in a given msc, asf, or csf, `full.ct`

can be correspondingly restricted via the argument `cond`

. For instance, `full.ct(d.educate, cond = "D + L <-> E")`

generates all logically possible value configurations of the factors in the set {D, L, E}, even though `d.educate`

contains further factors. The argument `cond`

is primarily used internally to speed up the execution of various functions in case of high-dimensional data.

The main area of application of `full.ct`

is data simulation in the context of inverse search trials benchmarking the output of `cna`

(see examples below). While `full.ct`

generates the space of all logically possible configurations of the factors in an analyzed factor set, `selectCases`

selects those configurations from this space that are compatible with a given data generating causal structure (i.e. the ground truth), that is, it selects the empirically possible configurations.

The method for class "cti" is for internal use only.

A `configTable`

of type `"cs"`

or `"mv"`

with the full enumeration of combinations of the factor values.

`configTable`

, `selectCases`

, `allCombs`

# x is a character vector. full.ct("A + B*c") full.ct("A=1*C=3 + B=2*C=1 + A=3*B=1") full.ct(c("A + b*C", "a*D")) full.ct("!A*-(B + c) + F") full.ct(c("A=1", "A=2", "B=1", "B=0", "C=13","C=45")) # x is a data frame. full.ct(d.educate) full.ct(d.jobsecurity) full.ct(d.pban) # x is a configTable. full.ct(configTable(d.jobsecurity)) full.ct(configTable(d.pban), cond = "C=1 + F=0 <-> V=1") # x is an integer. full.ct(6) # x is a list. full.ct(list(A = 0:1, B = 0:1, C = 0:1)) # cs full.ct(list(A = 1:2, B = 0:1, C = 23:25)) # mv # Simulating crisp-set data. groundTruth.1 <- "(A*b + C*d <-> E)*(E*H + I*k <-> F)" fullData <- full.ct(groundTruth.1) idealData <- selectCases(groundTruth.1, fullData) # Introduce 20% data fragmentation. fragData <- idealData[-sample(1:nrow(idealData), nrow(idealData)*0.2), ] # Introduce 10% random noise. (realData <- rbind(ct2df(fullData[sample(1:nrow(fullData), nrow(fragData)*0.1), ]), fragData)) # Simulating multi-value data. groundTruth.2 <- "(JO=3 + TS=1*PE=3 <-> ES=1)*(ES=1*HI=4 + IQ=2*KT=5 <-> FA=1)" fullData <- full.ct(list(JO=1:3, TS=1:2, PE=1:3, ES=1:2, HI=1:4, IQ=1:5, KT=1:5, FA=1:2)) idealData <- selectCases(groundTruth.2, fullData) # Introduce 20% data fragmentation. fragData <- idealData[-sample(1:nrow(idealData), nrow(idealData)*0.2), ] # Introduce 10% random noise. (realData <- rbind(ct2df(fullData[sample(1:nrow(fullData), nrow(fragData)*0.1), ]), fragData))

[Package *cna* version 3.2.0 Index]