returnVertexOrder {CoCoRaw}R Documentation

Return vertex order

Description

Return vertex orderings, including MaxCard, LexM and paths.

Usage

returnVertexOrder(model = FALSE, invers.order = FALSE, default.order = TRUE,
                  max.card = FALSE, path.order = FALSE, sub.path = FALSE,
                  marked = paste(";"), u = "", v = "",
                  names = NULL, levels = NULL, to.factor = NULL,
                  discrete = NULL, continuous = NULL, data = NULL,
                  object = .object.of.model(model, data = data, names = names,
                                            levels = levels, to.factor = to.factor,
                                            discrete = discrete,
                                            continuous = continuous, ...), ...)

Arguments

model See returnModel.
invers.order Logical, if invers.order is TRUE then .
default.order Logical, if default.order is TRUE then .
max.card Logical, if max.card is TRUE then .
path.order Logical, if path.order is TRUE then .
sub.path Logical, if sub.path is TRUE then .
marked A character string, marked then .
u A character string, u then .
v A character string, v then .
names A character string, names ...
levels A vector of integers, levels ...
to.factor A vector of integers, to.factor ...
discrete A vector of integers or a character string, discrete ...
continuous A vector of integers or a character string, continuous ...
data See exportCoCo.
object See exportCoCo.
... Additional arguments to generate the CoCo object from the data argument. See propertyModel.

Value

Author(s)

Jens Henrik Badsberg

References

Badsberg, J.H.: A guide to CoCo, JSS, 2001 ( http://www.jstatsoft.org/v06/i04/ ) and Badsberg, J.H.: Xlisp+CoCo, Aalborg University, 1996.

See Also

~~objects to See Also as coco.init, ~~~

Examples

library(CoCoCg);

# Without "data" does not require ending the CoCo object:

# returnVertexOrder("ab,xy", continuous = "xy");

# With CoCo object:

data(Reinis);
CoCoObject <- makeCoCo();
enterTable(Reinis, object = CoCoObject);

# Enter the saturated model:    
enterModel("*", object = CoCoObject);

# Generate some models, here by "backward":
backward(recursive = TRUE, headlong = TRUE, coherent = TRUE, 
         follow = TRUE, object = CoCoObject);

# Show the model list:
showModel("all", object = CoCoObject);

n <- returnModelNumber("last", object = CoCoObject);
for (i in 1:n) {
  showFormula(i, object = CoCoObject);
  showVertexOrder(i, object = CoCoObject);
  print(returnVertexOrder(i, object = CoCoObject));
}

returnVertexOrder(9, object = CoCoObject);
returnVertexOrder(9, max.card = TRUE, object = CoCoObject);
returnVertexOrder(9, default.order = FALSE, max.card = TRUE, object = CoCoObject);
returnVertexOrder(9, default.order = FALSE, max.card = FALSE, object = CoCoObject);

returnVertexOrder(9, marked = "AB;", object = CoCoObject);
returnVertexOrder(9, marked = "EF;", object = CoCoObject);

returnVertexOrder(9, u = "B;", v = "F;", 
                  path.order = TRUE, sub.path = TRUE, object = CoCoObject);
returnVertexOrder(9, u = "C;", v = "F;", 
                  path.order = TRUE, sub.path = TRUE, object = CoCoObject);

endCoCo(CoCoObject);

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #

data(Fuchs82);

CoCoObject <- makeCoCo();
enterTable(Fuchs82, object = CoCoObject);

enterModel("mdp,da,am,dg,gs,sa", object = CoCoObject);

returnVertexOrder(model = "current", 
                  path.order = TRUE, marked = paste("pd"),
                  u = "m", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", invers.order = TRUE,
                  path.order = TRUE, marked = paste("pd"),
                  u = "m", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", sub.path = TRUE,
                  path.order = TRUE, marked = paste("pd"),
                  u = "m", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", 
                  path.order = TRUE, marked = paste("adps"),
                  u = "m", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", sub.path = TRUE,
                  path.order = TRUE, marked = paste("adps"),
                  u = "m", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", 
                  path.order = TRUE, marked = paste("adms"),
                  u = "p", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", sub.path = TRUE,
                  path.order = TRUE, marked = paste("adms"),
                  u = "p", v = "g", object = CoCoObject);

returnVertexOrder(model = "current", 
                  path.order = TRUE, marked = paste("adms"),
                  u = "g", v = "p", object = CoCoObject);

returnVertexOrder(model = "current", sub.path = TRUE,
                  path.order = TRUE, marked = paste("adms"),
                  u = "g", v = "p", object = CoCoObject); 

showVertexOrder();

# Default order:
VertexOrder <- returnVertexOrder(model = "current",
                                 invers.order = FALSE,
                                 object = CoCoObject); 
VertexOrder

# Default order, inverse:
InverseOrder <- returnVertexOrder(model = "current",
                                  invers.order = TRUE,
                                  object = CoCoObject); 
InverseOrder

# Lex order:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = FALSE,
                  object = CoCoObject); 

# Lex order, inverse:
returnVertexOrder(model = "current", invers.order = TRUE,
                  default.order = FALSE,  max.card = FALSE,
                  object = CoCoObject); 

# Max-card order:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = TRUE,
                  object = CoCoObject); 

# Max-card order, inverse:
returnVertexOrder(model = "current", invers.order = TRUE,
                  default.order = FALSE,  max.card = TRUE,
                  object = CoCoObject); 

##

# Marked order, default:
returnVertexOrder(model = "current", invers.order = FALSE,
                  marked = "g", object = CoCoObject); 

# Marked order, Lex:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = FALSE,
                  marked = "g", object = CoCoObject); 

# (Marked order), Max-card:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = TRUE,
                  marked = "g", object = CoCoObject); 

##

# Marked order, default:
returnVertexOrder(model = "current", invers.order = FALSE,
                  marked = "d", object = CoCoObject); 

# Marked order, Lex:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = FALSE,
                  marked = "d", object = CoCoObject); 

# (Marked order), Max-card:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = TRUE,
                  marked = "d", object = CoCoObject); 

##

# Marked order, default:
returnVertexOrder(model = "current", invers.order = FALSE,
                  marked = "p", object = CoCoObject); 

# Marked order, Lex:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = FALSE,
                  marked = "p", object = CoCoObject); 

# (Marked order), Max-card:
returnVertexOrder(model = "current", invers.order = FALSE,
                  default.order = FALSE,  max.card = TRUE,
                  marked = "p", object = CoCoObject); 

endCoCo(CoCoObject);

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #

library(CoCoCg);
data(Rats);
CoCoObject <- makeCoCoCg();
enterDataFrame(Rats, object = CoCoObject);
fullModel <- makeModel(enterModel("*", object = CoCoObject));

# Generate some models, here by "backward":
backward(recursive = TRUE, headlong = TRUE, coherent = TRUE, follow = TRUE,
         object = CoCoObject);

homogeneModel <- makeModel(enterModel("[[ab]] / [[aby][abx]] / [[x^][abxy][y^]]",
                             object = CoCoObject));

enterModel("ab,bx,xy", object = CoCoObject);

enterModel("ax,xy,yb", object = CoCoObject);

enterModel("xa,ab,by", object = CoCoObject);

# Show the model list:
showModel("all", object = CoCoObject);

n <- returnModelNumber("last", object = CoCoObject);
for (i in 1:n) {
  showFormula(i, object = CoCoObject);
  print(returnVertexOrder(i, object = CoCoObject));
}

endCoCo(CoCoObject);

[Package Contents]