code
stringlengths 1
13.8M
|
|---|
context("winver")
test_that("winver_ver", {
cases <- list(
list(c("", "Microsoft Windows [Version 6.3.9600]"), "6.3.9600"),
list("Microsoft Windows [version 6.1.7601]", "6.1.7601"),
list("Microsoft Windows [vers\u00e3o 10.0.18362.207]", "10.0.18362.207"))
source(system.file("tools", "winver.R", package = "ps"), local = TRUE)
for (x in cases) expect_identical(winver_ver(x[[1]]), x[[2]])
})
test_that("winver_wmic", {
cases <- list(
list(c("\r", "\r", "Version=6.3.9600\r", "\r", "\r", "\r"),
"6.3.9600"),
list(c("\r", "\r", "version=6.3.9600\r", "\r", "\r", "\r"),
"6.3.9600"),
list(c("\r", "\r", "vers\u00e3o=6.3.9600\r", "\r", "\r", "\r"),
"6.3.9600"))
source(system.file("tools", "winver.R", package = "ps"), local = TRUE)
for (x in cases) expect_identical(winver_wmic(x[[1]]), x[[2]])
})
|
options(width=80)
options(prompt = "R> ", continue = "+ ", digits = 4, useFancyQuotes = FALSE)
require(ic.infer, quietly=TRUE)
contrasts(grades$HSR) <- "contr.treatment"
contrasts(grades$ACTC) <- "contr.treatment"
limo.grades <- lm(meanGPA ~ HSR + ACTC, grades, weights = n)
summary(limo.grades)
limo.bodyfat <- lm(BodyFat ~ ., bodyfat)
summary(limo.bodyfat)
grades.diff <- grades
contrasts(grades.diff$HSR) <- "contr.diff"
contrasts(grades.diff$ACTC) <- "contr.diff"
contrasts(grades.diff$HSR)
limo.grades.diff <- lm(meanGPA ~ HSR + ACTC, grades.diff, weights = n)
summary(limo.grades.diff)
ui.treat <- make.mon.ui(grades$HSR)
ui.treat
ui.diff <- make.mon.ui(grades.diff$HSR)
ui.diff
make.mon.ui(5, type = "mean")
options(width=100)
HSRmon <- ic.est(coef(limo.grades)[2:9],
ui = ui.treat,
Sigma = vcov(limo.grades)[2:9, 2:9])
HSRmon
HSReq <- ic.est(coef(limo.grades)[2:9],
ui = ui.treat,
Sigma = vcov(limo.grades)[2:9, 2:9], meq = 3)
HSReq
summary(HSRmon)
summary(ic.test(HSReq), brief = FALSE)
summary(ic.test(HSReq, TP = 2))
HSReq.large <- ic.est(coef(limo.grades),
ui = ui.treat,
Sigma = vcov(limo.grades), index = 2:9, meq = 3)
summary(ic.test(HSReq.large, TP = 11,
ui0.11 = cbind(rep(0, 16), diag(1, 16))))
summary(ic.test(HSReq, TP = 21, meq.alt = 2))
orlimo.grades <- orlm(limo.grades,
ui = ui.treat, index = 2:9)
summary(orlimo.grades, brief = TRUE)
orlimo.bodyfat <- orlm(limo.bodyfat,
ui = diag(1,3), boot = TRUE)
summary(orlimo.bodyfat)
or.relimp(limo.bodyfat, ui = diag(1, 3))
require(relaimpo, quietly=TRUE)
calc.relimp(limo.bodyfat)$lmg
|
fetch <- function(x, places, urls,
verbose = opts_flow$get("verbose")){
if(is.null(verbose))
verbose = FALSE
y = sapply(places, list.files, pattern = paste0(x, "$"),
full.names = TRUE)
y = as.character(unlist(y))
if(verbose > 1)
message(y)
return(y)
}
fetch_pipes <- function(x,
places,
last_only = FALSE,
urls = opts_flow$get("flowr_pipe_urls"),
silent = FALSE,
verbose = opts_flow$get("verbose"),
ask = TRUE){
if(missing(places)){
places = c(
system.file(package = "flowr", "pipelines"),
system.file(package = "flowr", "inst/pipelines"),
system.file(package = "ngsflows", "pipelines"),
system.file(package = "ngsflows", "inst/pipelines"),
strsplit(opts_flow$get("flow_pipe_paths"), ",")[[1]],
getwd())
places = places[!places == ""]
}
if(verbose)
message("> searching for pipes in the following places: \n ", paste(na.omit(places), collapse = "\n "), "\n")
if(missing(x)){
message("> since no search pattern was supplied, here is the complete list of available pipelines:")
x = ".*"
}
ext = tools::file_ext(x)
if(!ext == ""){
x = gsub(paste0(ext, "$"), "", x)
warning("> It is best to supply only the name of the pipeline, without the extension. ",
"We add a .R extention before searching. Also, this name also corresponds, ",
"to the R function.")
}else{
ext = ".R"
}
fl = paste0(x, ext)
if(file.exists(fl))
r = file_path_as_absolute(fl)
else
r = fetch(paste0("^", x, ext, "$"), places = places, urls = urls, verbose = FALSE)
if(length(r) == 0){
}
r = unique(r)
def = gsub("R$", "def", r)
def = ifelse(file.exists(def), def, NA)
conf = gsub("R$", "conf", r)
conf = ifelse(file.exists(conf), conf, NA)
pipes = data.frame(name = file_path_sans_ext(basename(r)),
def = def,
conf = conf,
pipe = r, stringsAsFactors = FALSE)
pipes = subset(pipes, !is.na(def))
if(nrow(pipes) == 0)
stop("> could not find a pipeline called '", x, "'. Run 'flowr fetch_pipes' to see the full list.\n")
pipe_print = pipes;
pipe_print$def = basename(as.character(pipe_print$def))
pipe_print$conf = basename(as.character(pipe_print$conf))
if(verbose > 0 & !silent)
message(paste(kable(pipe_print), collapse = "\n"))
if(last_only){
if(nrow(pipes) > 1 & x != ".*")
message("> Found multiple pipelines with the same name, will use the last from above list")
pipes = tail(pipes, 1)
}
invisible(pipes)
}
load_pipe <- function(x){
}
fetch_conf <- function(x = "flowr.conf", places, ...){
if(missing(places)){
places = c(
system.file(package = "flowr", "conf"),
system.file(package = "flowr", "inst/conf"),
file.path(path.expand("~"), "flowr/conf/flowr.conf"),
opts_flow$get("flow_conf_path"),
getwd())
}
ext = tools::file_ext(x)
if(ext == "")
x = paste0(x, ".conf")
x = paste0(x, "$")
fetch(x, places = places, ...)
}
search_conf <- function(...){
.Deprecated("fetch_conf")
fetch_conf(...)
}
avail_pipes <- function(){
}
|
regime <- function(TS, q=c(0.9, 0.1), text="d", by="hdoy", y.lims=NA) {
opar <- graphics::par(no.readonly = TRUE)
hyrstart <- as.numeric(subset(TS, TS$hmonth==1)$month[1])
if (by=="hdoy") {
doy <- as.factor(TS$hdoy)
} else {
doy <- as.factor(TS$doy)
}
Qdoy <- array(data=NA, c(max(as.numeric(doy)),6))
colnames(Qdoy)<- c("MaxQ", "MinQ", "MeanQ", "Q90", "Q10", "Median")
Qdoy[,1]<-tapply(TS$Flow, doy, max, na.rm=TRUE)
Qdoy[,2]<-tapply(TS$Flow, doy, min, na.rm=TRUE)
Qdoy[,3]<-tapply(TS$Flow, doy, mean, na.rm=TRUE)
Qdoy[,4]<-tapply(TS$Flow, doy, stats::quantile, q[1], na.rm=TRUE)
Qdoy[,5]<-tapply(TS$Flow, doy, stats::quantile, q[2], na.rm=TRUE)
Qdoy[,6]<-tapply(TS$Flow, doy, stats::median, na.rm=TRUE)
mdoy <- as.numeric(unique(doy))
xx <- c(1:max(as.numeric(doy)),max(as.numeric(doy)):1)
yy <- c(Qdoy[,4],Qdoy[max(as.numeric(doy)):1,5])
graphics::par(mar=c(4,4,2,2))
if (!is.null(text)) {graphics::par(oma=c(0,0,1,0))}
yl1=expression(paste("Discharge (m" ^{3}, "/s)"))
if (!is.na(y.lims[1])) {
graphics::plot(Qdoy[,1], col="
xlab="", ylab="", xaxt="n", ylim=y.lims)
} else {
y.lims <- range(pretty(c(0, TS$Flow)))
graphics::plot(Qdoy[,1], col="
xlab="", ylab="", xaxt="n", ylim=y.lims)
}
graphics::title(ylab=yl1, line=2)
graphics::points(Qdoy[,2], col="
graphics::polygon(xx, yy, col="gray", border="
graphics::points(Qdoy[,3],col="
graphics::points(Qdoy[,6], col="gray50", type="l", lwd=2)
if (by == "hdoy") {
axis_doy.internal(hyrstart)
} else {
axis_doy.internal(1)
}
SYMnames <- c("maximum", paste(as.character(max(q)), "quantile"), "mean", "median",
paste(as.character(min(q)), "quantile"), "minimum")
SYMcol <- c("
graphics::legend("topleft", legend = SYMnames, lwd = c(NA, 1, 2, 2, 1, NA),
lty = c(NA, 1, 1, 1, 1, NA),
pch = c(19, NA, NA, NA, NA, 19), pt.cex = 0.5, col = SYMcol, cex=0.7)
if (!is.null(text)) {
if (text == "d") {
stinfo <- station.info(TS, Plot=F)
text <- paste("ID: ", stinfo[1],", NAME: ", stinfo[2],
", PROV/STATE: ", stinfo[3], sep = "")
}
graphics::mtext(text, side=3, line=0, outer=T, cex=0.7)
}
on.exit(suppressWarnings(graphics::par(opar)))
}
|
test_that("can generate a basic request", {
req <- request_generate(
"sheets.spreadsheets.get",
list(spreadsheetId = "abc123"),
token = NULL
)
expect_identical(req$method, "GET")
expect_match(
req$url,
"^https://sheets.googleapis.com/v4/spreadsheets/abc123\\?key=.+"
)
expect_null(req$token)
})
|
test_that("str_before_last_dot works", {
expect_equal(str_before_last_dot(c("spreadsheet1.csv", "doc2.doc")),
c("spreadsheet1", "doc2"),
check.attributes = FALSE
)
})
test_that("`str_before_nth()` works", {
string <- "ab..cd..de..fg..h"
expect_equal(str_before_nth(string, "\\.", -3), "ab..cd..de.",
check.attributes = FALSE
)
expect_equal(str_before_nth(string, ".", -3), "ab..cd..de..fg",
check.attributes = FALSE
)
expect_equal(str_before_nth(rep(string, 2), fixed("."), -3),
rep("ab..cd..de.", 2),
check.attributes = FALSE
)
expect_equal(str_before_last(rep(string, 2), fixed(".")),
rep("ab..cd..de..fg.", 2),
check.attributes = FALSE
)
expect_equal(str_before_last(character(), 1:3), character())
string <- "abxxcdxxdexxfgxxh"
expect_equal(str_before_nth(string, "e", 1:2), c("abxxcdxxd", NA))
})
|
"example_resource1"
|
netmeta <- function(TE, seTE,
treat1, treat2, studlab,
data = NULL, subset = NULL,
sm,
level = gs("level"),
level.ma = gs("level.ma"),
fixed = gs("fixed"),
random = gs("random") | !is.null(tau.preset),
prediction = FALSE,
level.predict = gs("level.predict"),
reference.group,
baseline.reference = TRUE,
small.values = "good",
all.treatments = NULL,
seq = NULL,
method.tau = "DL",
tau.preset = NULL,
tol.multiarm = 0.001,
tol.multiarm.se = NULL,
details.chkmultiarm = FALSE,
sep.trts = ":",
nchar.trts = 666,
nchar.studlab = 666,
func.inverse = invmat,
n1 = NULL,
n2 = NULL,
event1 = NULL,
event2 = NULL,
incr = NULL,
sd1 = NULL,
sd2 = NULL,
time1 = NULL,
time2 = NULL,
backtransf = gs("backtransf"),
title = "",
keepdata = gs("keepdata"),
control = NULL,
warn = TRUE, warn.deprecated = gs("warn.deprecated"),
nchar = nchar.trts,
...) {
chklevel(level)
chklevel(level.predict)
chklogical(prediction)
missing.reference.group <- missing(reference.group)
chklogical(baseline.reference)
small.values <- setchar(small.values, c("good", "bad"))
if (!is.null(all.treatments))
chklogical(all.treatments)
method.tau <- setchar(method.tau, c("DL", "ML", "REML"))
if (!is.null(tau.preset))
chknumeric(tau.preset, min = 0, length = 1)
chknumeric(tol.multiarm, min = 0, length = 1)
if (!is.null(tol.multiarm.se))
chknumeric(tol.multiarm.se, min = 0, length = 1)
chklogical(details.chkmultiarm)
missing.sep.trts <- missing(sep.trts)
chkchar(sep.trts)
chknumeric(nchar.studlab, length = 1)
chklogical(backtransf)
chkchar(title)
chklogical(keepdata)
chklogical(warn)
chklogical(baseline.reference)
args <- list(...)
chklogical(warn.deprecated)
level.ma <- deprecated(level.ma, missing(level.ma), args, "level.comb",
warn.deprecated)
chklevel(level.ma)
missing.fixed <- missing(fixed)
fixed <- deprecated(fixed, missing.fixed, args, "comb.fixed",
warn.deprecated)
chklogical(fixed)
random <-
deprecated(random, missing(random), args, "comb.random", warn.deprecated)
chklogical(random)
nchar.trts <-
deprecated2(nchar.trts, missing(nchar.trts), nchar, missing(nchar),
warn.deprecated)
chknumeric(nchar.trts, min = 1, length = 1)
nulldata <- is.null(data)
if (nulldata)
data <- sys.frame(sys.parent())
mf <- match.call()
TE <- eval(mf[[match("TE", names(mf))]],
data, enclos = sys.frame(sys.parent()))
missing.reference.group.pairwise <- FALSE
if (is.data.frame(TE) & !is.null(attr(TE, "pairwise"))) {
is.pairwise <- TRUE
sm <- attr(TE, "sm")
if (missing.reference.group) {
missing.reference.group.pairwise <- TRUE
reference.group <- attr(TE, "reference.group")
if (is.null(reference.group))
reference.group <- ""
else
missing.reference.group <- FALSE
}
keep.all.comparisons <- attr(TE, "keep.all.comparisons")
if (!is.null(keep.all.comparisons) && !keep.all.comparisons)
stop("First argument is a pairwise object created with ",
"'keep.all.comparisons = FALSE'.",
call. = TRUE)
seTE <- TE$seTE
treat1 <- TE$treat1
treat2 <- TE$treat2
studlab <- TE$studlab
if (!is.null(TE$n1))
n1 <- TE$n1
if (!is.null(TE$n2))
n2 <- TE$n2
if (!is.null(TE$event1))
event1 <- TE$event1
if (!is.null(TE$event2))
event2 <- TE$event2
if (!is.null(TE$incr))
incr <- TE$incr
if (!is.null(TE$sd1))
sd1 <- TE$sd1
if (!is.null(TE$sd2))
sd2 <- TE$sd2
if (!is.null(TE$time1))
time1 <- TE$time1
if (!is.null(TE$time2))
time2 <- TE$time2
pairdata <- TE
data <- TE
TE <- TE$TE
}
else {
is.pairwise <- FALSE
if (missing(sm))
if (!is.null(data) && !is.null(attr(data, "sm")))
sm <- attr(data, "sm")
else
sm <- ""
seTE <- eval(mf[[match("seTE", names(mf))]],
data, enclos = sys.frame(sys.parent()))
treat1 <- eval(mf[[match("treat1", names(mf))]],
data, enclos = sys.frame(sys.parent()))
treat2 <- eval(mf[[match("treat2", names(mf))]],
data, enclos = sys.frame(sys.parent()))
studlab <- eval(mf[[match("studlab", names(mf))]],
data, enclos = sys.frame(sys.parent()))
n1 <- eval(mf[[match("n1", names(mf))]],
data, enclos = sys.frame(sys.parent()))
n2 <- eval(mf[[match("n2", names(mf))]],
data, enclos = sys.frame(sys.parent()))
event1 <- eval(mf[[match("event1", names(mf))]],
data, enclos = sys.frame(sys.parent()))
event2 <- eval(mf[[match("event2", names(mf))]],
data, enclos = sys.frame(sys.parent()))
incr <- eval(mf[[match("incr", names(mf))]],
data, enclos = sys.frame(sys.parent()))
sd1 <- eval(mf[[match("sd1", names(mf))]],
data, enclos = sys.frame(sys.parent()))
sd2 <- eval(mf[[match("sd2", names(mf))]],
data, enclos = sys.frame(sys.parent()))
time1 <- eval(mf[[match("time1", names(mf))]],
data, enclos = sys.frame(sys.parent()))
time2 <- eval(mf[[match("time2", names(mf))]],
data, enclos = sys.frame(sys.parent()))
}
chknumeric(TE)
chknumeric(seTE)
if (!any(!is.na(TE) & !is.na(seTE)))
stop("Missing data for estimates (argument 'TE') and ",
"standard errors (argument 'seTE') in all studies.\n ",
"No network meta-analysis possible.",
call. = FALSE)
k.Comp <- length(TE)
if (is.factor(treat1))
treat1 <- as.character(treat1)
if (is.factor(treat2))
treat2 <- as.character(treat2)
if (length(studlab) == 0) {
if (warn)
warning("No information given for argument 'studlab'. ",
"Assuming that comparisons are from independent studies.",
call. = FALSE)
studlab <- seq(along = TE)
}
studlab <- as.character(studlab)
subset <- eval(mf[[match("subset", names(mf))]],
data, enclos = sys.frame(sys.parent()))
missing.subset <- is.null(subset)
if (!is.null(event1) & !is.null(event2))
available.events <- TRUE
else
available.events <- FALSE
if (!is.null(n1) & !is.null(n2))
available.n <- TRUE
else
available.n <- FALSE
if (available.events & is.null(incr))
incr <- rep(0, length(event2))
available.means <- FALSE
if (!is.null(sd1) & !is.null(sd2))
available.sds <- TRUE
else
available.sds <- FALSE
if (!is.null(time1) & !is.null(time2))
available.times <- TRUE
else
available.times <- FALSE
if (keepdata) {
if (nulldata & !is.pairwise)
data <- data.frame(.studlab = studlab, stringsAsFactors = FALSE)
else if (nulldata & is.pairwise) {
data <- pairdata
data$.studlab <- studlab
}
else
data$.studlab <- studlab
data$.order <- seq_along(studlab)
data$.treat1 <- treat1
data$.treat2 <- treat2
data$.TE <- TE
data$.seTE <- seTE
data$.event1 <- event1
data$.n1 <- n1
data$.event2 <- event2
data$.n2 <- n2
data$.incr <- incr
data$.sd1 <- sd1
data$.sd2 <- sd2
data$.time1 <- time1
data$.time2 <- time2
wo <- data$.treat1 > data$.treat2
if (any(wo)) {
data$.TE[wo] <- -data$.TE[wo]
ttreat1 <- data$.treat1
data$.treat1[wo] <- data$.treat2[wo]
data$.treat2[wo] <- ttreat1[wo]
if (isCol(data, ".n1") & isCol(data, ".n2")) {
tn1 <- data$.n1
data$.n1[wo] <- data$.n2[wo]
data$.n2[wo] <- tn1[wo]
}
if (isCol(data, ".event1") & isCol(data, ".event2")) {
tevent1 <- data$.event1
data$.event1[wo] <- data$.event2[wo]
data$.event2[wo] <- tevent1[wo]
}
if (isCol(data, ".sd1") & isCol(data, ".sd2")) {
tsd1 <- data$.sd1
data$.sd1[wo] <- data$.sd2[wo]
data$.sd2[wo] <- tsd1[wo]
}
if (isCol(data, ".time1") & isCol(data, ".time2")) {
ttime1 <- data$.time1
data$.time1[wo] <- data$.time2[wo]
data$.time2[wo] <- ttime1[wo]
}
}
if (!missing.subset) {
if (length(subset) == dim(data)[1])
data$.subset <- subset
else {
data$.subset <- FALSE
data$.subset[subset] <- TRUE
}
}
}
if (!missing.subset) {
if ((is.logical(subset) & (sum(subset) > k.Comp)) ||
(length(subset) > k.Comp))
stop("Length of subset is larger than number of studies.",
call. = FALSE)
TE <- TE[subset]
seTE <- seTE[subset]
treat1 <- treat1[subset]
treat2 <- treat2[subset]
studlab <- studlab[subset]
if (!is.null(n1))
n1 <- n1[subset]
if (!is.null(n2))
n2 <- n2[subset]
if (!is.null(event1))
event1 <- event1[subset]
if (!is.null(event2))
event2 <- event2[subset]
if (!is.null(incr))
incr <- incr[subset]
if (!is.null(sd1))
sd1 <- sd1[subset]
if (!is.null(sd2))
sd2 <- sd2[subset]
if (!is.null(time1))
time1 <- time1[subset]
if (!is.null(time2))
time2 <- time2[subset]
}
labels <- sort(unique(c(treat1, treat2)))
if (compmatch(labels, sep.trts)) {
if (!missing.sep.trts)
warning("Separator '", sep.trts,
"' used in at least one treatment label. ",
"Try to use predefined separators: ",
"':', '-', '_', '/', '+', '.', '|', '*'.",
call. = FALSE)
if (!compmatch(labels, ":"))
sep.trts <- ":"
else if (!compmatch(labels, "-"))
sep.trts <- "-"
else if (!compmatch(labels, "_"))
sep.trts <- "_"
else if (!compmatch(labels, "/"))
sep.trts <- "/"
else if (!compmatch(labels, "+"))
sep.trts <- "+"
else if (!compmatch(labels, "."))
sep.trts <- "-"
else if (!compmatch(labels, "|"))
sep.trts <- "|"
else if (!compmatch(labels, "*"))
sep.trts <- "*"
else
stop("All predefined separators (':', '-', '_', '/', '+', ",
"'.', '|', '*') are used in at least one treatment label.",
"\n Please specify a different character that should be ",
"used as separator (argument 'sep.trts').",
call. = FALSE)
}
if (!is.null(seq))
seq <- setseq(seq, labels)
else {
seq <- labels
if (is.numeric(seq))
seq <- as.character(seq)
}
if (any(treat1 == treat2))
stop("Treatments must be different (arguments 'treat1' and 'treat2').",
call. = FALSE)
tabnarms <- table(studlab)
sel.narms <- !is.wholenumber((1 + sqrt(8 * tabnarms + 1)) / 2)
if (sum(sel.narms) == 1)
stop(paste("Study '", names(tabnarms)[sel.narms],
"' has a wrong number of comparisons.",
"\n Please provide data for all treatment comparisons",
" (two-arm: 1; three-arm: 3; four-arm: 6, ...).",
sep = ""),
call. = FALSE)
if (sum(sel.narms) > 1)
stop(paste("The following studies have a wrong number of comparisons: ",
paste(paste("'", names(tabnarms)[sel.narms], "'", sep = ""),
collapse = ", "),
"\n Please provide data for all treatment comparisons",
" (two-arm: 1; three-arm: 3; four-arm: 6, ...).",
sep = ""),
call. = FALSE)
n.subnets <- netconnection(treat1, treat2, studlab)$n.subnets
if (n.subnets > 1)
stop(paste("Network consists of ", n.subnets, " separate sub-networks.\n ",
"Use R function 'netconnection' to identify sub-networks.",
sep = ""),
call. = FALSE)
excl <- is.na(TE) | is.na(seTE) | seTE <= 0
if (any(excl)) {
if (keepdata)
data$.excl <- excl
dat.NAs <- data.frame(studlab = studlab[excl],
treat1 = treat1[excl],
treat2 = treat2[excl],
TE = format(round(TE[excl], 4)),
seTE = format(round(seTE[excl], 4)),
stringsAsFactors = FALSE
)
if (warn)
warning("Comparison",
if (sum(excl) > 1) "s",
" with missing TE / seTE or zero seTE not considered ",
"in network meta-analysis.",
call. = FALSE)
if (warn) {
cat(paste("Comparison",
if (sum(excl) > 1) "s",
" not considered in network meta-analysis:\n", sep = ""))
prmatrix(dat.NAs, quote = FALSE, right = TRUE,
rowlab = rep("", sum(excl)))
cat("\n")
}
studlab <- studlab[!(excl)]
treat1 <- treat1[!(excl)]
treat2 <- treat2[!(excl)]
TE <- TE[!(excl)]
seTE <- seTE[!(excl)]
if (!is.null(n1))
n1 <- n1[!excl]
if (!is.null(n2))
n2 <- n2[!excl]
if (!is.null(event1))
event1 <- event1[!excl]
if (!is.null(event2))
event2 <- event2[!excl]
if (!is.null(incr))
incr <- incr[!excl]
if (!is.null(sd1))
sd1 <- sd1[!excl]
if (!is.null(sd2))
sd2 <- sd2[!excl]
if (!is.null(time1))
time1 <- time1[!excl]
if (!is.null(time2))
time2 <- time2[!excl]
seq <- seq[seq %in% unique(c(treat1, treat2))]
labels <- labels[labels %in% unique(c(treat1, treat2))]
}
tabnarms <- table(studlab)
sel.narms <- !is.wholenumber((1 + sqrt(8 * tabnarms + 1)) / 2)
if (sum(sel.narms) == 1)
stop(paste("After removing comparisons with missing treatment effects",
" or standard errors,\n study '",
names(tabnarms)[sel.narms],
"' has a wrong number of comparisons.",
" Please check data and\n consider to remove study",
" from network meta-analysis.",
sep = ""),
call. = FALSE)
if (sum(sel.narms) > 1)
stop(paste("After removing comparisons with missing treatment effects",
" or standard errors,\n the following studies have",
" a wrong number of comparisons: ",
paste(paste("'", names(tabnarms)[sel.narms], "'", sep = ""),
collapse = ", "),
"\n Please check data and consider to remove studies",
" from network meta-analysis.",
sep = ""),
call. = FALSE)
n.subnets <- netconnection(treat1, treat2, studlab)$n.subnets
if (n.subnets > 1)
stop(paste("After removing comparisons with missing treatment effects",
" or standard errors,\n network consists of ",
n.subnets, " separate sub-networks.\n ",
"Please check data and consider to remove studies",
" from network meta-analysis.",
sep = ""),
call. = FALSE)
wo <- treat1 > treat2
if (any(wo)) {
TE[wo] <- -TE[wo]
ttreat1 <- treat1
treat1[wo] <- treat2[wo]
treat2[wo] <- ttreat1[wo]
if (available.n) {
tn1 <- n1
n1[wo] <- n2[wo]
n2[wo] <- tn1[wo]
}
if (available.events) {
tevent1 <- event1
event1[wo] <- event2[wo]
event2[wo] <- tevent1[wo]
}
if (available.means) {
tmean1 <- mean1
mean1[wo] <- mean2[wo]
mean2[wo] <- tmean1[wo]
}
if (available.sds) {
tsd1 <- sd1
sd1[wo] <- sd2[wo]
sd2[wo] <- tsd1[wo]
}
if (available.times) {
ttime1 <- time1
time1[wo] <- time2[wo]
time2[wo] <- ttime1[wo]
}
}
if (missing.reference.group | missing.reference.group.pairwise) {
go.on <- TRUE
i <- 0
while (go.on) {
i <- i + 1
sel.i <-
!is.na(TE) & !is.na(seTE) &
(treat1 == labels[i] | treat2 == labels[i])
if (sum(sel.i) > 0) {
go.on <- FALSE
reference.group <- labels[i]
}
else if (i == length(labels)) {
go.on <- FALSE
reference.group <- ""
}
}
}
if (is.null(all.treatments))
if (reference.group == "")
all.treatments <- TRUE
else
all.treatments <- FALSE
if (reference.group != "")
reference.group <- setref(reference.group, labels)
p0 <- prepare(TE, seTE, treat1, treat2, studlab,
func.inverse = func.inverse)
chkmultiarm(p0$TE, p0$seTE, p0$treat1, p0$treat2, p0$studlab,
tol.multiarm = tol.multiarm, tol.multiarm.se = tol.multiarm.se,
details = details.chkmultiarm)
tdata <- data.frame(studies = p0$studlab, narms = p0$narms,
order = p0$order,
stringsAsFactors = FALSE)
tdata <- tdata[!duplicated(tdata[, c("studies", "narms")]), , drop = FALSE]
studies <- tdata$studies[order(tdata$order)]
narms <- tdata$narms[order(tdata$order)]
res.f <- nma.ruecker(p0$TE, sqrt(1 / p0$weights),
p0$treat1, p0$treat2,
p0$treat1.pos, p0$treat2.pos,
p0$narms, p0$studlab,
sm,
level, level.ma,
p0$seTE, 0, sep.trts,
method.tau,
func.inverse)
trts <- rownames(res.f$A.matrix)
if (is.null(tau.preset)) {
if (method.tau %in% c("ML", "REML")) {
dat.tau <-
data.frame(studlab = studlab,
treat1 = treat1, treat2 = treat2,
TE = TE, seTE = seTE)
if (available.n) {
dat.tau$n1 <- n1
dat.tau$n2 <- n2
}
if (available.events) {
dat.tau$event1 <- event1
dat.tau$event2 <- event2
dat.tau$incr <- incr
}
if (available.means) {
dat.tau$mean1 <- mean1
dat.tau$mean2 <- mean2
}
if (available.sds) {
dat.tau$sd1 <- sd1
dat.tau$sd2 <- sd2
}
if (available.times) {
dat.tau$time1 <- time1
dat.tau$time2 <- time2
}
keep <- logical(0)
wo <- logical(0)
for (i in unique(dat.tau$studlab)) {
d.i <- dat.tau[dat.tau$studlab == i, , drop = FALSE]
trts.i <- unique(sort(c(d.i$treat1, d.i$treat2)))
if (reference.group %in% trts.i)
ref.i <- reference.group
else
ref.i <- rev(trts.i)[1]
keep.i <- !(d.i$treat1 != ref.i & d.i$treat2 != ref.i)
wo.i <- d.i$treat1 == ref.i
keep <- c(keep, keep.i)
wo <- c(wo, wo.i)
}
dat.tau <- dat.tau[keep, , drop = FALSE]
dat.tau$id <- seq_along(dat.tau$TE)
wo <- wo[keep]
if (sum(wo) > 0) {
dat.tau$TE[wo] <- -dat.tau$TE[wo]
t2.i <- dat.tau$treat2
e2.i <- dat.tau$event2
n2.i <- dat.tau$n2
sd2.i <- dat.tau$sd2
time2.i <- dat.tau$time2
dat.tau$treat2[wo] <- dat.tau$treat1[wo]
dat.tau$event2[wo] <- dat.tau$event1[wo]
dat.tau$n2[wo] <- dat.tau$n1[wo]
dat.tau$sd2[wo] <- dat.tau$sd1[wo]
dat.tau$time2[wo] <- dat.tau$time2[wo]
dat.tau$treat1[wo] <- t2.i[wo]
dat.tau$event1[wo] <- e2.i[wo]
dat.tau$n1[wo] <- n2.i[wo]
dat.tau$sd1[wo] <- sd2.i[wo]
dat.tau$time1[wo] <- time2.i[wo]
}
ncols1 <- ncol(dat.tau)
dat.tau <- contrmat(dat.tau, grp1 = "treat1", grp2 = "treat2")
ncols2 <- ncol(dat.tau)
newnames <- paste0("V", seq_len(ncols2 - ncols1))
names(dat.tau)[(ncols1 + 1):ncols2] <- newnames
trts.tau <- newnames[-length(newnames)]
formula.trts <-
as.formula(paste("~ ", paste(trts.tau, collapse = " + "), " - 1"))
if (available.n &
(available.events | available.times | (available.sds))) {
dat.tau <- dat.tau[order(dat.tau$studlab), ]
V <- bldiag(lapply(split(dat.tau, dat.tau$studlab), calcV, sm = sm))
}
else
V <- dat.tau$seTE^2
dat.tau.TE <- dat.tau$TE
rma1 <-
runNN(rma.mv,
list(yi = dat.tau.TE, V = V,
data = dat.tau,
mods = formula.trts,
random = as.call(~ factor(id) | studlab),
rho = 0.5,
method = method.tau, control = control))
tau <- sqrt(rma1$tau2)
}
else
tau <- res.f$tau
}
else
tau <- tau.preset
p1 <- prepare(TE, seTE, treat1, treat2, studlab, tau, func.inverse)
res.r <- nma.ruecker(p1$TE, sqrt(1 / p1$weights),
p1$treat1, p1$treat2,
p1$treat1.pos, p1$treat2.pos,
p1$narms, p1$studlab,
sm,
level, level.ma,
p1$seTE, tau, sep.trts,
method.tau,
func.inverse)
TE.random <- res.r$TE.pooled
seTE.random <- res.r$seTE.pooled
df.Q <- res.f$df
if (df.Q == 0)
prediction <- FALSE
if (df.Q >= 2) {
seTE.predict <- sqrt(seTE.random^2 + tau^2)
ci.p <- ci(TE.random, seTE.predict, level.predict, df.Q - 1)
p.lower <- ci.p$lower
p.upper <- ci.p$upper
diag(p.lower) <- 0
diag(p.upper) <- 0
}
else {
seTE.predict <- p.lower <- p.upper <- seTE.random
seTE.predict[!is.na(seTE.predict)] <- NA
p.lower[!is.na(p.lower)] <- NA
p.upper[!is.na(p.upper)] <- NA
}
o <- order(p0$order)
designs <- designs(res.f$treat1, res.f$treat2, res.f$studlab,
sep.trts = sep.trts)
res <- list(studlab = res.f$studlab[o],
treat1 = res.f$treat1[o],
treat2 = res.f$treat2[o],
TE = res.f$TE[o],
seTE = res.f$seTE.orig[o],
seTE.adj = res.f$seTE[o],
seTE.adj.fixed = res.f$seTE[o],
seTE.adj.random = res.r$seTE[o],
design = designs$design[o],
event1 = event1,
event2 = event2,
n1 = n1,
n2 = n2,
incr = incr,
sd1 = sd1,
sd2 = sd2,
time1 = time1,
time2 = time2,
k = res.f$k,
m = res.f$m,
n = res.f$n,
d = length(unique(designs$design)),
trts = trts,
k.trts = rowSums(res.f$A.matrix),
n.trts = if (available.n) NA else NULL,
events.trts = if (available.events) NA else NULL,
n.arms = NA,
multiarm = NA,
studies = studies,
narms = narms,
designs = unique(sort(designs$design)),
comparisons = "",
TE.nma.fixed = res.f$TE.nma[o],
seTE.nma.fixed = res.f$seTE.nma[o],
lower.nma.fixed = res.f$lower.nma[o],
upper.nma.fixed = res.f$upper.nma[o],
statistic.nma.fixed = res.f$statistic.nma[o],
pval.nma.fixed = res.f$pval.nma[o],
leverage.fixed = res.f$leverage[o],
w.fixed = res.f$w.pooled[o],
Q.fixed = res.f$Q.pooled[o],
TE.fixed = res.f$TE.pooled,
seTE.fixed = res.f$seTE.pooled,
lower.fixed = res.f$lower.pooled,
upper.fixed = res.f$upper.pooled,
statistic.fixed = res.f$statistic.pooled,
pval.fixed = res.f$pval.pooled,
TE.nma.random = res.r$TE.nma[o],
seTE.nma.random = res.r$seTE.nma[o],
lower.nma.random = res.r$lower.nma[o],
upper.nma.random = res.r$upper.nma[o],
statistic.nma.random = res.r$statistic.nma[o],
pval.nma.random = res.r$pval.nma[o],
w.random = res.r$w.pooled[o],
TE.random = TE.random,
seTE.random = seTE.random,
lower.random = res.r$lower.pooled,
upper.random = res.r$upper.pooled,
statistic.random = res.r$statistic.pooled,
pval.random = res.r$pval.pooled,
seTE.predict = seTE.predict,
lower.predict = p.lower,
upper.predict = p.upper,
prop.direct.fixed = NA,
prop.direct.random = NA,
TE.direct.fixed = res.f$TE.direct,
seTE.direct.fixed = res.f$seTE.direct,
lower.direct.fixed = res.f$lower.direct,
upper.direct.fixed = res.f$upper.direct,
statistic.direct.fixed = res.f$statistic.direct,
pval.direct.fixed = res.f$pval.direct,
TE.direct.random = res.r$TE.direct,
seTE.direct.random = res.r$seTE.direct,
lower.direct.random = res.r$lower.direct,
upper.direct.random = res.r$upper.direct,
statistic.direct.random = res.r$statistic.direct,
pval.direct.random = res.r$pval.direct,
Q.direct = res.r$Q.direct,
tau.direct = sqrt(res.r$tau2.direct),
tau2.direct = res.r$tau2.direct,
I2.direct = res.r$I2.direct,
TE.indirect.fixed = NA,
seTE.indirect.fixed = NA,
lower.indirect.fixed = NA,
upper.indirect.fixed = NA,
statistic.indirect.fixed = NA,
pval.indirect.fixed = NA,
TE.indirect.random = NA,
seTE.indirect.random = NA,
lower.indirect.random = NA,
upper.indirect.random = NA,
statistic.indirect.random = NA,
pval.indirect.random = NA,
Q = res.f$Q,
df.Q = df.Q,
pval.Q = res.f$pval.Q,
I2 = res.f$I2,
lower.I2 = res.f$lower.I2,
upper.I2 = res.f$upper.I2,
tau = tau,
tau2 = tau^2,
Q.heterogeneity = NA,
df.Q.heterogeneity = NA,
pval.Q.heterogeneity = NA,
Q.inconsistency = NA,
df.Q.inconsistency = NA,
pval.Q.inconsistency = NA,
Q.decomp = res.f$Q.decomp,
A.matrix = res.f$A.matrix,
X.matrix = res.f$B.matrix[o, ],
B.matrix = res.f$B.matrix[o, ],
L.matrix.fixed = res.f$L.matrix,
Lplus.matrix.fixed = res.f$Lplus.matrix,
L.matrix.random = res.r$L.matrix,
Lplus.matrix.random = res.r$Lplus.matrix,
Q.matrix = res.f$Q.matrix,
G.matrix = res.f$G.matrix[o, o, drop = FALSE],
H.matrix.fixed = res.f$H.matrix[o, o, drop = FALSE],
H.matrix.random = res.r$H.matrix[o, o, drop = FALSE],
n.matrix = if (available.n) NA else NULL,
events.matrix = if (available.events) NA else NULL,
P.fixed = NA,
P.random = NA,
Cov.fixed = res.f$Cov,
Cov.random = res.r$Cov,
treat1.pos = res.f$treat1.pos[o],
treat2.pos = res.f$treat2.pos[o],
sm = sm,
method = "Inverse",
level = level,
level.ma = level.ma,
fixed = fixed,
random = random,
comb.fixed = fixed,
comb.random = random,
prediction = prediction,
level.predict = level.predict,
reference.group = reference.group,
baseline.reference = baseline.reference,
all.treatments = all.treatments,
seq = seq,
method.tau = method.tau,
tau.preset = tau.preset,
tol.multiarm = tol.multiarm,
tol.multiarm.se = tol.multiarm.se,
details.chkmultiarm = details.chkmultiarm,
func.inverse = deparse(substitute(func.inverse)),
sep.trts = sep.trts,
nchar.trts = nchar.trts,
nchar.studlab = nchar.studlab,
backtransf = backtransf,
title = title,
warn = warn,
call = match.call(),
version = packageDescription("netmeta")$Version
)
class(res) <- "netmeta"
n <- res$n
res$prop.direct.fixed <-
netmeasures(res, random = FALSE, warn = warn)$proportion
res$prop.direct.random <-
suppressWarnings(netmeasures(res, random = TRUE,
tau.preset = res$tau,
warn = FALSE)$proportion)
if (is.logical(res$prop.direct.fixed))
res$prop.direct.fixed <- as.numeric(res$prop.direct.fixed)
if (is.logical(res$prop.direct.random))
res$prop.direct.random <- as.numeric(res$prop.direct.random)
res$comparisons <-
names(res$prop.direct.random)[!is.zero(res$prop.direct.random)]
P.fixed <- P.random <- matrix(NA, n, n)
colnames(P.fixed) <- rownames(P.fixed) <-
colnames(P.random) <- rownames(P.random) <- trts
if (n == 2) {
res$prop.direct.fixed <- 1
res$prop.direct.random <- 1
names(res$prop.direct.fixed) <-
names(res$prop.direct.random) <- paste(labels, collapse = sep.trts)
sel <- row(P.fixed) != col(P.fixed)
P.fixed[sel] <- 1
P.random[sel] <- 1
}
else {
k <- 0
for (i in 1:(n - 1)) {
for (j in (i + 1):n) {
k <- k + 1
P.fixed[i, j] <- P.fixed[j, i] <- res$prop.direct.fixed[k]
P.random[i, j] <- P.random[j, i] <- res$prop.direct.random[k]
}
}
}
TE.direct.fixed <- res$TE.direct.fixed
TE.direct.random <- res$TE.direct.random
TE.direct.fixed[abs(P.fixed) < .Machine$double.eps^0.5] <- 0
TE.direct.random[abs(P.random) < .Machine$double.eps^0.5] <- 0
res$P.fixed <- P.fixed
res$P.random <- P.random
P.fixed[abs(P.fixed - 1) < .Machine$double.eps^0.5] <- NA
P.fixed[P.fixed > 1] <- NA
P.random[abs(P.random - 1) < .Machine$double.eps^0.5] <- NA
P.random[P.random > 1] <- NA
ci.if <- ci((res$TE.fixed - P.fixed * TE.direct.fixed) / (1 - P.fixed),
sqrt(res$seTE.fixed^2 / (1 - P.fixed)),
level = level)
res$TE.indirect.fixed <- ci.if$TE
res$seTE.indirect.fixed <- ci.if$seTE
res$lower.indirect.fixed <- ci.if$lower
res$upper.indirect.fixed <- ci.if$upper
res$statistic.indirect.fixed <- ci.if$statistic
res$pval.indirect.fixed <- ci.if$p
ci.ir <- ci((res$TE.random - P.random * TE.direct.random) / (1 - P.random),
sqrt(res$seTE.random^2 / (1 - P.random)),
level = level)
res$TE.indirect.random <- ci.ir$TE
res$seTE.indirect.random <- ci.ir$seTE
res$lower.indirect.random <- ci.ir$lower
res$upper.indirect.random <- ci.ir$upper
res$statistic.indirect.random <- ci.ir$statistic
res$pval.indirect.random <- ci.ir$p
res$small.values <- small.values
if (any(res$narms > 2)) {
tdata1 <- data.frame(studlab = res$studlab,
.order = seq(along = res$studlab))
tdata2 <- data.frame(studlab = as.character(res$studies),
narms = res$narms)
tdata12 <- merge(tdata1, tdata2,
by = "studlab", all.x = TRUE, all.y = FALSE,
sort = FALSE)
tdata12 <- tdata12[order(tdata12$.order), ]
res$n.arms <- tdata12$narms
res$multiarm <- tdata12$narms > 2
}
else {
res$n.arms <- rep(2, length(res$studlab))
res$multiarm <- rep(FALSE, length(res$studlab))
}
if (any(res$multiarm))
res$leverage.fixed[res$multiarm] <- NA
if (res$d > 1) {
dd <- decomp.design(res, warn = FALSE)
res$Q.heterogeneity <- dd$Q.decomp$Q[2]
res$Q.inconsistency <- dd$Q.decomp$Q[3]
res$df.Q.heterogeneity <- dd$Q.decomp$df[2]
res$df.Q.inconsistency <- dd$Q.decomp$df[3]
res$pval.Q.heterogeneity <- dd$Q.decomp$pval[2]
res$pval.Q.inconsistency <- dd$Q.decomp$pval[3]
}
if (keepdata) {
data$.design <- designs(data$.treat1, data$.treat2, data$.studlab,
sep = sep.trts)$design
res$data <- merge(data,
data.frame(.studlab = res$studies,
.narms = res$narms),
by = ".studlab",
stringsAsFactors = FALSE)
res$data <- res$data[order(res$data$.order), ]
res$data$.order <- NULL
}
if (available.n) {
res$n.matrix <- netmatrix(res, n1 + n2, func = "sum")
dat.n <- data.frame(studlab = c(studlab, studlab),
treat = c(treat1, treat2),
n = c(n1, n2))
dat.n <- dat.n[!duplicated(dat.n[, c("studlab", "treat")]), ]
dat.n <- by(dat.n$n, dat.n$treat, sum, na.rm = TRUE)
res$n.trts <- as.vector(dat.n[trts])
names(res$n.trts) <- trts
}
if (available.events) {
res$events.matrix <- netmatrix(res, event1 + event2, func = "sum")
dat.e <- data.frame(studlab = c(studlab, studlab),
treat = c(treat1, treat2),
n = c(event1, event2))
dat.e <- dat.e[!duplicated(dat.e[, c("studlab", "treat")]), ]
dat.e <- by(dat.e$n, dat.e$treat, sum, na.rm = TRUE)
res$events.trts <- as.vector(dat.e[trts])
names(res$events.trts) <- trts
}
if (method.tau %in% c("ML", "REML")) {
res$.metafor <- rma1
res$.dat.tau <- dat.tau
res$.V <- V
res$.formula.trts <- formula.trts
res$version.metafor <- packageDescription("metafor")$Version
}
res
}
|
evaluateLogConDens <- function(xs, res, which = 1:5, gam = NULL, print = FALSE){
x <- res$x
w <- res$w
phi <- res$phi
Fhat <- res$Fhat
IsKnot <- res$IsKnot
n <- length(x)
values.mat <- matrix(NA, ncol = 6, nrow = length(xs))
if (max(which) > 3){
if (is.null(gam) == TRUE){
VarFn <- LocalVariance(x = x, w = w, phi = phi)
gam <- sqrt(res$sig ^ 2 - VarFn)
}
js <- 2:n
xj <- x[js - 1]
xj1 <- x[js]
f <- exp(phi)
a <- c(NA, diff(phi) / diff(x))[js]
}
for (i in 1:length(xs)){
values <- rep(NA, 5)
x0 <- xs[i]
if (x0 < x[1]){values[1:3] <- c(-Inf, 0, 0)}
if (x0 == x[1]){values[1:3] <- c(phi[1], exp(phi[1]), 0)}
if (x0 > x[n]){values[1:3] <- c(-Inf, 0, 1)}
if (x0 > x[1] && x0 <= x[n]){
x.knot <- res$knots
phi.knot <- phi[IsKnot > 0]
k <- length(x.knot[x.knot < x0])
if ((1 %in% which) | (2 %in% which)){
phi.x0 <- (1 - (x0 - x.knot[k]) / (x.knot[k + 1] - x.knot[k])) * phi.knot[k] + (x0 - x.knot[k]) / (x.knot[k + 1] - x.knot[k]) * phi.knot[k + 1]
f.x0 <- exp(phi.x0)
values[1:2] <- c(phi.x0, f.x0)
}
if (3 %in% which){
j <- length(x[x < x0])
Fhat.x0 <- Fhat[j] + (x[j + 1] - x[j]) * J00(phi[j], phi[j + 1], (x0 - x[j]) / (x[j + 1] - x[j]))
values[3] <- Fhat.x0
}
}
if (max(which) > 3){qs <- Q00(x = x0, a = a, u = xj, v = xj1, gamma = gam, QFhat = (5 %in% which))}
if (4 %in% which){values[4] <- sum(f[js - 1] * qs$q)}
if (5 %in% which){values[5] <- sum(f[js - 1] * qs$Q)}
values.mat[i, ] <- c(x0, values)
i10 <- i / length(xs) * 10
if ((round(i10) == i10) & (print == TRUE)){print(paste(i10 * 10, "% of computation of smooth estimates done", sep = ""))}
}
values.mat[, c(FALSE, (1:5 %in% which) == FALSE)] <- NA
colnames(values.mat) <- c("xs", "log-density", "density", "CDF", "smooth.density", "smooth.CDF")
return(values.mat)
}
|
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
)
suppressMessages({
library(seecolor)
library(ggplot2)
library(fansi)
library(crayon)
})
old.hooks <- fansi::set_knit_hooks(knitr::knit_hooks)
options(crayon.enabled=TRUE)
print_color(c("red", "navy", "pink", "
print_color(c("red", "navy", "pink", "
type = "r")
print_color(palette(rainbow(6)), blank.len = 1)
print_color(palette(rainbow(6)), type = 'r')
p1 <- ggplot(mpg) +
geom_point(aes(displ, cyl, color = manufacturer))
print_color(p1)
print_color(p1, type = 'r')
|
seq_interpolate <- function(from, to, ...) {
value <- seq(from, to, ...)
value[-c(1, length(value))]
}
interpolate_sensor_records <- function(record_set, schema, verbose) {
n_to_interpolate <- sum(record_set$Result.interpolate)
if (n_to_interpolate == 0) return(record_set)
stop(paste(
"Interpolation is broken and may not be",
"proper or necessary."
))
if (verbose) cat(
"\r Interpolating values for", n_to_interpolate,
"missing SENSOR_DATA samples"
)
record_set <- data.frame(record_set, stringsAsFactors = FALSE)
record_set$index <- seq(nrow(record_set))
interps <- record_set[
record_set$Result.interpolate != 0,
]
new_values <- matrix(
NA,
nrow = sum(interps$Result.interpolate),
ncol = ncol(interps)
)
new_values <- stats::setNames(
data.frame(new_values),
names(interps)
)
class(new_values$Timestamp) <- class(
interps$Timestamp
)
new_values$Type <- interps$Type[1]
for (i in seq(nrow(interps))) {
new_indices <- sum(
interps$Result.interpolate[seq(0, i - 1)]
) + 1
new_indices <- seq(
new_indices,
new_indices + (interps$Result.interpolate[i] - 1)
)
from <- interps$index[i]
to <- from + 1
length_out <- 2 +
interps$Result.interpolate[i]
new_values$Timestamp[new_indices] <-
interps$Timestamp[i]
cols_to_update <- setdiff(
names(new_values),
c("Timestamp", "Type")
)
for (col_name in cols_to_update) {
new_values[new_indices, col_name] <- do.call(
c,
mapply(
seq_interpolate,
from = record_set[from, col_name],
to = record_set[to, col_name],
length.out = length_out,
SIMPLIFY = FALSE
)
)
}
}
record_set <- rbind(record_set, new_values)
record_set <- record_set[order(record_set$index), ]
record_set$Result.interpolate <- NULL
record_set$index <- NULL
if (verbose) cat(" ............. COMPLETE")
return(record_set)
}
|
stresstest_exercise <- function(file, n = 100,
verbose = TRUE, seeds = NULL,
stop_on_error = length(as.character(unlist(file))) < 2, ...)
{
file <- as.character(unlist(file))
if(length(file) > 1L) {
rval <- list()
for(i in seq_along(file)) {
attr(n, "stress.list") <- TRUE
rval[[file[i]]] <- stresstest_exercise(file[i], n = n,
verbose = verbose, seeds = seeds, stop_on_error = stop_on_error, ...)
}
class(rval) <- c("stress.list", "stress", "list")
} else {
if (!(tolower(substr(file, nchar(file) - 3L, nchar(file))) %in% c(".rnw", ".rmd"))) file <- paste0(file, ".Rnw")
if (!file.exists(file) && !file.exists(file.path(find.package("exams"), "exercises", file))) stop(sprintf("Cannot find file: %s.", file))
stress_env <- .GlobalEnv
if(!is.null(seeds)) {
if (length(seeds) < n) { n <- length(seeds) } else { seeds <- seeds[1:n] }
} else { seeds <- 1:n }
sq <- objects <- vector("list", length = n)
times <- rep(0, n)
if(verbose & !is.null(attr(n, "stress.list")))
cat("---\ntesting file:", file, "\n---\n")
for(i in 1:n) {
set.seed(seeds[i])
if(verbose) cat(seeds[i])
.global_obj_before <- ls(envir = stress_env)
times[i] <- system.time(xtmp <- try(xexams(file, driver = list("sweave" = list("envir" = stress_env)), ...),
silent = TRUE))["elapsed"]
.global_obj_after <- ls(envir = stress_env)
ex_objects <- .global_obj_after[!(.global_obj_after %in% .global_obj_before)]
objects[[i]] <- list()
for(j in ex_objects)
objects[[i]][[j]] <- get(j, envir = stress_env)
remove(list = ex_objects, envir = stress_env)
if(inherits(xtmp, "try-error")) {
cat(xtmp)
msg <- paste('an error occured when running file: "', file, '" using seed ', seeds[i], '!', sep = '')
if(stop_on_error) {
stop(msg)
} else {
warning(msg)
return(list("file" = file, "seed" = seeds[i], "error" = xtmp))
}
}
sq[[i]] <- list("solution" = xtmp[[1]][[1]]$metainfo$solution,
"questionlist" = xtmp[[1]][[1]]$questionlist)
if(i < n & verbose) cat("/")
}
if(verbose) cat("\n")
extype <- xtmp[[1]][[1]]$metainfo$type
solutions <- lapply(sq, function(x) { x$solution })
questions <- lapply(sq, function(x) { x$questionlist })
objects <- lapply(objects, function(x) {
isf <- unlist(sapply(x, is.function))
n <- unlist(sapply(x, length))
if(is.null(isf))
isf <- rep(FALSE, length(x))
x[which((n == 1) & !isf)]
})
nobj <- unique(unlist(lapply(objects, names)))
objects <- lapply(objects, function(x) {
x <- as.data.frame(x[names(x) %in% nobj])
if(!all(ok <- nobj %in% names(x))) {
for(j in nobj[!ok])
x[[j]] <- NA
}
x <- x[, nobj, drop = FALSE]
x
})
objects <- do.call("rbind", objects)
if(any(names(objects) %in% (no <- ls(envir = stress_env))))
rm(list = names(objects)[names(objects) %in% no])
rval <- list("seeds" = seeds, "runtime" = times)
if(nrow(objects) > 0)
rval$objects <- objects
if(extype %in% c("num", "schoice", "mchoice")) {
if(extype == "num") {
if(length(solutions[[1]]) > 1)
solutions <- lapply(solutions, mean)
rval$solution <- unlist(solutions)
nchoice <- 0
}
if(extype == "schoice") {
pmat <- do.call("rbind", solutions)
pmat <- t(t(pmat) * 1:ncol(pmat))
rval$position <- pmat
rank <- do.call("rbind", lapply(questions, function(x) {
x <- gsub("$", "", gsub(" ", "", x, fixed = TRUE), fixed = TRUE)
if(!all(is.na(suppressWarnings(as.numeric(x)))))
x <- as.numeric(x)
rank(x, ties.method = "min")
}))
if(all(!is.na(suppressWarnings(as.numeric(gsub("$", "", questions[[1]], fixed = TRUE)))))) {
questions <- lapply(questions, function(x) {
as.numeric(gsub("$", "", x, fixed = TRUE)) })
questions <- do.call("rbind", questions)
i <- as.integer(rowSums(pmat))
sol_num <- rep(NA, nrow(pmat))
for(j in 1:nrow(pmat))
sol_num[j] <- questions[j, i[j]]
rval$solution <- sol_num
}
rank <- (pmat > 0) * rank
rval$rank <- as.factor(as.integer(rowSums(rank)))
nchoice <- NCOL(pmat)
}
if(extype == "mchoice") {
ex_mat <- do.call("rbind", solutions)
pmat <- t(t(ex_mat) * 1:ncol(ex_mat))
rval$position <- pmat
rval$ntrue <- apply(ex_mat, 1, sum)
rank <- lapply(questions, function(x) {
order(gsub("$", "", gsub(" ", "", x, fixed = TRUE), fixed = TRUE), decreasing = TRUE)
})
rank <- do.call("rbind", rank)
rval$rank <- rank * do.call("rbind", solutions)
nchoice <- NCOL(pmat)
}
} else {
rval$solutions <- solutions
nchoice <- 0
}
class(rval) <- c("stress", "list")
attr(rval, "exinfo") <- c("file" = file, "type" = extype, "nchoice" = nchoice)
}
return(rval)
}
as.data.frame.stress <- function(x, ...)
{
names(x) <- paste(".", names(x), sep = "")
do.call("cbind", x)
}
plot.stress <- function(x, type = c("overview", "solution", "rank", "runtime"),
threshold = NULL, variables = NULL, spar = TRUE, ask = TRUE, ...)
{
op <- par(no.readonly = TRUE)
on.exit(par(op))
type <- match.arg(type)
rainbow <- function(n) hcl(h = seq(0, 360 * (n - 1)/n, length = n), c = 50, l = 70)
if(inherits(x, "stress.list")) {
par("ask" = ask)
for(i in names(x)) {
cat("stresstest plots for file:", i, "\n")
plot.stress(x[[i]], type = type, threshold = threshold,
variables = variables, spar = spar, ask = ask, ...)
}
} else {
if(type == "overview") {
k <- 0
for(j in c("runtime", "solution", "position", "rank", "ntrue")) {
if(!is.null(x[[j]]) & !is.list(x[[j]]))
k <- k + 1
}
if(spar) {
if(k < 3)
par(mfrow = c(1, k))
else
par(mfrow = c(2, 2))
}
if(!is.null(x$runtime)) {
tr <- range(x$runtime)
hist(x$runtime, freq = FALSE,
main = paste("Runtimes ", fmt(min(tr), 4), "-", fmt(max(tr), 4), sep = ""),
xlab = "Time", col = "lightgray")
}
if(!is.null(x$solution) & !is.list(x$solution)) {
hist(x$solution, freq = FALSE,
main = "Histogram of numeric solutions", xlab = "Solutions",
col = "lightgray")
}
nchoice <- as.numeric(attr(x, "exinfo")["nchoice"])
if(!is.null(x$position)) {
ptab <- table(factor(x$position, levels = 0:nchoice))
ptab <- ptab[names(ptab) != "0"]
barplot(ptab, ylab = "n", main = "Position of correct solution",
xlab = "Position", col = rainbow(ncol(x$position)))
}
if(!is.null(x$rank)) {
ptab <- table(factor(x$rank, levels = 0:nchoice))
ptab <- ptab[names(ptab) != "0"]
barplot(ptab, ylab = "n", main = "Rank of correct solution",
xlab = "Rank", col = rainbow(ncol(x$position)))
}
if(!is.null(x$ntrue)) {
barplot(table(x$ntrue), main = "Number of correct solutions", ylab = "n",
col = rainbow(length(unique(x$ntrue))))
}
}
spineplot2 <- function(x, y, threshold = NULL, ...) {
if(is.numeric(x) | is.factor(x)) {
if(is.factor(x)) {
if(nlevels(x) > 10)
return(invisible(NULL))
}
if(length(unique(x)) > 1) {
breaks <- if(is.numeric(x)) {
unique(quantile(x,
seq(0, 1, length = min(c(floor(0.5 * length(unique(x))), 10))),
na.rm = TRUE))
} else NULL
if(length(breaks) < 2)
breaks <- NULL
if((length(unique(x)) < 10) & !is.factor(x))
spineplot(as.factor(x), y, ...)
else
spineplot(x, y, breaks = breaks, ...)
}
}
}
plot2 <- function(x, y, threshold = NULL, ylab = NULL, ...) {
if((is.numeric(x) | is.factor(x)) & (length(unique(x)) > 1)) {
if(is.factor(x)) {
if(nlevels(x) > 10)
return(invisible(NULL))
}
if(is.null(threshold)) {
plot(x, y, ylab = ylab, ...)
} else {
breaks <- if(is.numeric(x)) {
unique(quantile(x,
seq(0, 1, length = min(c(floor(0.5 * length(unique(x))), 10))),
na.rm = TRUE))
} else NULL
if(length(breaks) < 2)
breaks <- NULL
ylab <- paste(ylab, "<=", threshold)
if((length(unique(x)) < 10) & !is.factor(x))
spineplot(as.factor(x), factor(y <= threshold), breaks = breaks, ylab = ylab, ...)
else
spineplot(x, factor(y <= threshold), breaks = breaks, ylab = ylab, ...)
}
}
}
if(!is.null(x$objects)) {
if(is.null(variables)) {
variables <- names(x$objects)
} else {
v2 <- NULL
for(j in variables)
v2 <- c(v2, grep(j, variables, value = TRUE, fixed = TRUE))
variables <- unique(v2)
}
par("ask" = ask)
if(spar) {
if(length(variables) > 2) {
if(length(variables) > 3)
par(mfrow = c(2, 2))
else
par(mfrow = c(1, 3))
} else {
par(mfrow = c(1, length(variables)))
}
}
if(type == "runtime") {
for(j in variables) {
plot2(x$objects[[j]], x$runtime, threshold = threshold,
xlab = j, ylab = "Runtime", main = paste("Runtimes vs.", j), ...)
}
}
if((type == "solution") & !is.list(x$solution) & !is.null(x$solution)) {
for(j in variables) {
plot2(x$objects[[j]], x$solution, threshold = threshold,
xlab = j, ylab = "Solution", main = paste("Solutions vs.", j), ...)
}
}
if((type == "rank") & !is.null(x$rank)) {
if(is.matrix(x$rank))
x$rank <- as.factor(apply(x$rank, 1, paste, collapse = "|"))
for(j in variables) {
spineplot2(x$objects[[j]], x$rank, xlab = j,
ylab = "Solution rank", main = paste("Solution rank frequencies:", j), ...)
}
}
}
}
invisible(NULL)
}
|
library("testthat")
library("spectrolab")
f_svc_added = "data_for_tests/data_svc_added_lines.sig"
f_svc_removed = "data_for_tests/data_svc_removed_lines.sig"
f_psr_added = "data_for_tests/data_psr_added_lines.sed"
f_psr_removed = "data_for_tests/data_psr_removed_lines.sed"
context("Parse svc and psr files by finding a data tag")
test_that("parser reads longer svc file", {
expect_s3_class(read_spectra(f_svc_added, "sig"), class = "spectra" )
})
test_that("parser reads shorter svc file", {
expect_s3_class(read_spectra(f_svc_removed, "sig"), class = "spectra" )
})
test_that("parser reads longer psr file", {
expect_s3_class(read_spectra(f_psr_added, "sed"), class = "spectra" )
})
test_that("parser reads shorter psr file", {
expect_s3_class(read_spectra(f_psr_removed, "sed"), class = "spectra" )
})
|
dandelion <- function (fact_load, bound = 0.5, mcex = c(1, 1), palet)
{
if (class(fact_load) != "loadings") {
cat(" Example : dandelion(loading object,bound=0)\n")
stop("please use a loadings object")
}
if ((bound < 0) || (bound > 1))
stop("bound must be between 0 and 1")
load_grid <- function(fact_load1, fact_load2, x3, y3, x2,
y2, tempx, tempy, col1) {
coln <- length(col1)
col2 <- rev(col1)
x4 <- seq(tempx, x3, by = (x3 - tempx) * (1/coln))
y4 <- seq(tempy, y3, by = (y3 - tempy) * (1/coln))
if (fact_load1 > 0 && fact_load2 < 0) {
for (k in 2:coln) polygon(c(x4[k], x2, x4[k - 1]),
c(y4[k], y2, y4[k - 1]), col = col2[k], border = col2[k])
}
else if (fact_load1 < 0 && fact_load2 > 0) {
for (k in 2:coln) polygon(c(x4[k], x2, x4[k - 1]),
c(y4[k], y2, y4[k - 1]), col = col1[k], border = col1[k])
}
else if (fact_load1 < 0 && fact_load2 < 0)
polygon(c(x3, x2, tempx), c(y3, y2, tempy), col = col2[1],
border = col2[1])
else if (fact_load1 > 0 && fact_load2 > 0)
polygon(c(x3, x2, tempx), c(y3, y2, tempy), col = col1[1],
border = col1[1])
}
old_par <- par(no.readonly = TRUE)
factor <- ncol(fact_load)
commun_fact <- apply(fact_load, 1, function(x) sum(x^2))
lambda <- apply(fact_load, 2, function(x) sum(x^2))
lambda2 <- sort(lambda, decreasing = TRUE)
count <- NULL
for (i in lambda2) count <- c(count, which(i == lambda))
count <- unique(count)
fact_load <- fact_load[, count]
lambda <- lambda2
unique_fact <- 1 - commun_fact
aci <- 360 * (lambda/nrow(fact_load))
if ((max(aci)/2) > (360 - sum(aci)))
aci <- (aci/360) * (360 - (max(aci)/2))
degreef <- (270 + c(0, cumsum(aci)))%%360
if (aci[1] > 180)
aci[1] <- 360 - aci[1]
limitt <- sqrt(2 * (1 - cos(aci * pi/180)))/2
limit <- limitt * 0.9
maxcex <- (lambda/max(lambda)) * mcex[1]
count <- NULL
count2 <- NULL
count3 <- NULL
for (i in 1:factor) {
for (j in 1:nrow(fact_load)) {
if (abs(fact_load[j, i]) == max(abs(fact_load[j,
]))) {
count <- c(count, j)
if (length(count2) == (i - 1))
count2 <- c(count2, j)
}
}
}
fact_load <- fact_load[count, ]
commun_fact <- commun_fact[count]
unique_fact <- 1-commun_fact
for (i in 1:factor) {
temp <- which(count == count2[i])
if (length(temp) != 0)
count3 <- c(count3, which(count == count2[i]))
}
xlimit <- cos(degreef * pi/180)
temp <- c(limitt, 0)
limord <- which(xlimit < 0)
temp[limord] <- -1 * temp[limord]
xlimit <- cos(degreef * pi/180) + temp
ylimit <- sin(-degreef * pi/180)
temp <- c(limitt, 0)
limord <- which(ylimit < 0)
temp[limord] <- -1 * temp[limord]
ylimit <- sin(-degreef * pi/180) + temp
xmax <- max(xlimit)
xmin <- min(xlimit)
ymax <- max(ylimit)
ymin <- min(ylimit)
if (max(limitt) > xmax)
xmax <- max(limitt)
if (max(limitt) > abs(xmin))
xmin <- -1 * max(limitt)
if (max(limitt) > ymax)
ymax <- max(limitt)
if (max(limitt) > abs(ymin))
ymin <- -1 * max(limitt)
par(mar = c(0, 0, 0, 0))
layout(matrix(c(1, 1, 1, 1, 2, 3, 4, 5), nrow = 4), widths = c(7,
3), heights = c(0.5, 1, 1, 1))
plot(1, type = "n", axes = FALSE, xlab = "", ylab = "",
xlim = c(xmin, xmax), ylim = c(ymin, ymax))
degreev <- (270 + 0:(nrow(fact_load) - 1) * (360/nrow(fact_load)))%%360
x2 = cos(degreef * pi/180)
y2 = sin(-degreef * pi/180)
srt2 <- 360 - degreev
bloc <- which((degreev - 270)%%360 > 180)
srt2[bloc] <- srt2[bloc] - 180
for (i in 1:factor) {
lines(c(0, x2[i]), c(0, y2[i]), type = "l", col = "black")
datanew <- abs(fact_load[, i])
bloc <- which(datanew <= bound)
if (length(bloc) > 0) {
datanew[bloc] <- rep(0, length(datanew[bloc]))
datanew[-bloc] <- (datanew[-bloc] - bound)/(1 -
bound)
}
else datanew <- (datanew - bound)/(1 - bound)
xm = x2[i] + limit[i] * cos(degreev * pi/180)
ym = y2[i] + limit[i] * sin(-degreev * pi/180)
x3 = x2[i] + (limit[i] * datanew) * (cos(degreev * pi/180))
y3 = y2[i] + (limit[i] * datanew) * (sin(-degreev *
pi/180))
if (fact_load[1, i] > 0)
col2 = palet[1]
if (fact_load[1, i] < 0)
col2 = palet[length(palet)]
polygon(c(x3[1], x2[i]), c(y3[1], y2[i]), col = col2,
border = col2)
lines(c(x3[1], xm[1]), c(y3[1], ym[1]), type = "l",
col = "grey")
for (j in 2:(nrow(fact_load) + 1)) {
jnew <- ((j - 1)%%(nrow(fact_load))) + 1
load_grid(fact_load[jnew, i], fact_load[j - 1, i],
x3[jnew], y3[jnew], x2[i], y2[i], x3[j - 1],
y3[j - 1], palet)
lines(c(x3[jnew], xm[jnew]), c(y3[jnew], ym[jnew]),
type = "l", col = "grey")
}
if ((length(count3) + 1) > i) {
if (length(count3) == i)
text_space <- count3[i]:nrow(fact_load)
else text_space <- count3[i]:(count3[i + 1] - 1)
for (k in text_space) {
x4 = x2[i] + limitt[i] * cos(degreev[k] * pi/180)
y4 = y2[i] + limitt[i] * sin(-degreev[k] * pi/180)
text(x4, y4, paste(abbreviate(rownames(fact_load)[k])),
cex = maxcex[i], srt = srt2[k])
}
}
}
x2 = cos(degreef[factor + 1] * pi/180)
y2 = sin(-degreef[factor + 1] * pi/180)
lines(c(0, x2), c(0, y2), type = "l", col = "black", lty = 2)
plot(1:10, type = "n", xlim = c(-1.5, 1.5), ylim = c(-1.5,
1.5), axes = FALSE)
legend(0, 0, c("pos. load.", "neg. load."),
col = c(palet[1], palet[length(palet)]),
text.col = "black", bg = "white", bty="n",
xjust = 0.5, yjust = 0.5, pch = c(15, 15), cex = 1.5)
par(mar = c(0, 0, 0.9, 0))
plot(1:10, type = "n", xlim = c(-1.5, 1.5), ylim = c(-1.5,
1.5), axes = FALSE)
title(main = "uniquenesses", cex.main = mcex[2])
x3 = cos(degreev * pi/180)
y3 = sin(-degreev * pi/180)
x4 = 1.25 * cos(degreev * pi/180)
y4 = 1.25 * sin(-degreev * pi/180)
x5 = unique_fact * cos(degreev * pi/180)
y5 = unique_fact * sin(-degreev * pi/180)
for (i in 1:nrow(fact_load)) {
lines(c(0, x3[i]), c(0, y3[i]), type = "l", col = "grey")
text(x4[i], y4[i], paste(abbreviate(rownames(fact_load)[i])),
cex = mcex[2], srt = srt2[i])
}
polygon(x5, y5, col = palet[1], border = palet[1])
plot(1:10, type = "n", xlim = c(-1.5, 1.5), ylim = c(-1.5,
1.5), axes = FALSE)
title(main = "communalities", cex.main = mcex[2])
x5 = commun_fact * cos(degreev * pi/180)
y5 = commun_fact * sin(-degreev * pi/180)
for (i in 1:nrow(fact_load)) {
lines(c(0, x3[i]), c(0, y3[i]), type = "l", col = "grey")
text(x4[i], y4[i], paste(abbreviate(rownames(fact_load)[i])),
cex = mcex[2], srt = srt2[i])
}
polygon(x5, y5, col = palet[1], border = palet[1])
par(mar = c(0, 0, 0, 0))
lam <- cbind(round(lambda, digits = 2), round(cumsum(lambda/nrow(fact_load)),
digits = 2))
lam <- round(lambda, digits = 2)
r.lam <- round(cumsum(lambda/nrow(fact_load)), digits = 2)
names(r.lam) <- paste("F", 1:factor, sep = ".")
par(mar=c(2, 2, 2, 2))
bar.g <- barplot(r.lam,mgp=c(3,0.5,0),ylim=c(0,1),main="Cum. Ratio")
text(bar.g,r.lam,lam,pos=3, offset=.2,font=2)
par(old_par)
invisible()
}
|
.T1EpSceptical_ <- function(level, c,
alternative = c("one.sided", "two.sided", "greater", "less"),
type = c("golden", "nominal", "liberal", "controlled")) {
stopifnot(is.numeric(level),
length(level) == 1,
is.finite(level),
0 < level, level < 1,
is.numeric(c),
length(c) == 1,
is.finite(c),
0 <= c,
!is.null(alternative))
alternative <- match.arg(alternative)
stopifnot(!is.null(type))
type <- match.arg(type)
alphas <- levelSceptical(level = level,
alternative = alternative,
type = type)
zas <- p2z(alphas, alternative = alternative)
if (alternative == "two.sided") {
if (c == 1) {
t1err <- 2*(1 - stats::pnorm(q = 2*zas))
return(t1err)
} else {
intFun <- function(zo) {
K <- zo^2/zas^2
zrmin <- zas*sqrt(1 + c/(K - 1))
2*(1 - stats::pnorm(q = zrmin))*stats::dnorm(x = zo)
}
}
}
if (alternative == "one.sided") {
if (c == 1) {
t1err <- 1 - stats::pnorm(q = 2*zas)
return(t1err)
} else {
intFun <- function(zo) {
K <- zo^2/zas^2
zrmin <- zas*sqrt(1 + c/(K - 1))
(1 - stats::pnorm(q = zrmin))*stats::dnorm(x = zo)
}
}
}
if (alternative == "greater") {
if (c == 1) {
t1err <- (1 - stats::pnorm(q = 2*zas))/2
return(t1err)
} else {
intFun <- function(zo) {
K <- zo^2/zas^2
zrmin <- zas*sqrt(1 + c/(K - 1))
(1 - stats::pnorm(q = zrmin))*stats::dnorm(x = zo)
}
}
}
if (alternative == "less") {
if (c == 1) {
t1err <- stats::pnorm(q = 2*zas)/2
return(t1err)
} else {
intFun <- function(zo) {
K <- zo^2/zas^2
zrmax <- zas*sqrt(1 + c/(K - 1))
stats::pnorm(q = zrmax)*stats::dnorm(x = zo)
}
}
}
if (alternative %in% c("one.sided", "two.sided")) {
t1err <- 2*stats::integrate(f = intFun, lower = zas, upper = Inf)$value
return(t1err)
}
if (alternative == "greater") {
t1err <- stats::integrate(f = intFun, lower = zas, upper = Inf)$value
return(t1err)
}
if (alternative == "less") {
t1err <- stats::integrate(f = intFun, lower = -Inf, upper = zas)$value
return(t1err)
}
return(t1err)
}
T1EpSceptical <- Vectorize(.T1EpSceptical_)
|
context("Deterministic ID")
library(rsvd)
set.seed(1234)
atol_float64 <- 1e-8
m = 50
n = 30
k = 10
testMat <- matrix(runif(m*k), m, k)
testMat <- testMat %*% t(testMat)
testMat <- testMat[,1:n]
id_out <- rid(testMat, rand=FALSE)
testMat.re = id_out$C %*% id_out$Z
testthat::test_that("Test 1: Interpolative decomposition (column) k=NULL", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = testMat[,id_out$idx] %*% id_out$Z
testthat::test_that("Test 2: Interpolative decomposition (column idx) k=NULL", {
testthat::expect_equal(testMat, testMat.re)
})
id_out <- rid(testMat, mode='row', rand=FALSE)
testMat.re = id_out$Z %*% id_out$R
testthat::test_that("Test 3: Interpolative decomposition (row) k=NULL", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = id_out$Z %*% testMat[id_out$idx,]
testthat::test_that("Test 4: Interpolative decomposition (row idx) k=NULL", {
testthat::expect_equal(testMat, testMat.re)
})
id_out <- rid(testMat, k=k, rand=FALSE)
testMat.re = id_out$C %*% id_out$Z
testthat::test_that("Test 5: Interpolative decomposition (column) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = testMat[,id_out$idx] %*% id_out$Z
testthat::test_that("Test 6: Interpolative decomposition (column idx) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
id_out <- rid(H(testMat), k=k, rand=FALSE)
testMat.re = id_out$C %*% id_out$Z
testthat::test_that("Test 9: Interpolative decomposition (row) k=k", {
testthat::expect_equal(H(testMat), testMat.re)
})
id_out <- rid(testMat, mode='row', k=k, rand=FALSE)
testMat.re = id_out$Z %*% id_out$R
testthat::test_that("Test 7: Interpolative decomposition (row) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = id_out$Z %*% testMat[id_out$idx,]
testthat::test_that("Test 8: Interpolative decomposition (row idx) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
id_out <- rid(H(testMat), mode='row', k=k, rand=FALSE)
testMat.re = id_out$Z %*% id_out$R
testthat::test_that("Test 9: Interpolative decomposition (row) k=k", {
testthat::expect_equal(H(testMat), testMat.re)
})
testMat <- matrix(runif(m*k), m, k) + 1i* matrix(runif(m*k), m, k)
testMat <- testMat %*% H(testMat)
testMat <- testMat[,1:n]
id_out <- rid(testMat, k=k, rand=FALSE)
testMat.re = id_out$C %*% id_out$Z
testthat::test_that("Test 9: Interpolative decomposition (column) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = testMat[,id_out$idx] %*% id_out$Z
testthat::test_that("Test 10: Interpolative decomposition (column idx) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
id_out <- rid(testMat, mode='row', k=k, rand=FALSE)
testMat.re = id_out$Z %*% id_out$R
testthat::test_that("Test 11: Interpolative decomposition (row) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
testMat.re = id_out$Z %*% testMat[id_out$idx,]
testthat::test_that("Test 12: Interpolative decomposition (row idx) k=k", {
testthat::expect_equal(testMat, testMat.re)
})
|
export_svg <- function(gv){
if(!requireNamespace("V8")) stop("V8 is required to export.",
call. = FALSE)
stopifnot(packageVersion("V8") >= "0.10")
if(!inherits(gv, "grViz")) "gv must be a grViz htmlwidget."
ct <- new_context("window")
invisible(ct$source(system.file("htmlwidgets/lib/viz/viz.js",
package = "DiagrammeR")))
svg <-
ct$call("Viz",
gv$x$diagram,
"svg",
gv$x$config$engine,
gv$x$config$options)
return(svg)
}
|
print.grotagplus <-
function(x,precision=c(est='sig3',stats='dec1',cor='dec2'),...)
{
is.in <- function(x, y)!is.na(match(x, y))
reduce <- function(comp,prec){
if(substring(prec,1,3)=='sig')
signif(comp,as.numeric(substring(prec,4)))
else if(substring(prec,1,3)=='dec')
round(comp,as.numeric(substring(prec,4)))
else stop('Invalid value for precision: "',prec,'"')
}
conv <- c(parest='est',parfix='est',stats='stats',
correlations='cor',Linf.k='est')
pr.comp <- c('model','parest',"parfix",'stats','correlations',"Linf.k")
pr.comp <- pr.comp[is.in(pr.comp,names(x))]
for(nam in pr.comp[-1])
x[[nam]] <- reduce(x[[nam]],precision[conv[nam]])
print.default(x[pr.comp])
}
|
context("problem (negative data)")
test_that("x=Raster, features=RasterStack", {
data(sim_pu_raster, sim_features)
sim_pu_raster[] <- sim_pu_raster[] * runif(length(sim_pu_raster[]), -1, 1)
sim_features[] <- sim_features[] * runif(length(sim_features[]), -1, 1)
expect_warning(x <- problem(sim_pu_raster, sim_features))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), names(sim_features))
expect_equal(x$zone_names(), names(sim_pu_raster))
expect_equal(x$number_of_features(), raster::nlayers(sim_features))
expect_equal(x$number_of_planning_units(),
length(raster::Which(!is.na(sim_pu_raster), cells = TRUE)))
expect_equal(x$number_of_total_units(), raster::ncell(sim_pu_raster))
expect_equal(x$planning_unit_indices(),
raster::Which(!is.na(sim_pu_raster), cells = TRUE))
expect_equivalent(x$planning_unit_costs(),
matrix(sim_pu_raster[[1]][!is.na(sim_pu_raster)], ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), names(sim_pu_raster))
expect_equivalent(x$feature_abundances_in_planning_units(),
matrix(raster::cellStats(raster::mask(sim_features, sim_pu_raster),
"sum"), ncol = 1))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
x$zone_names())
expect_equal(rownames(x$feature_abundances_in_planning_units()),
x$feature_names())
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(raster::cellStats(sim_features, "sum"), ncol = 1))
expect_equal(colnames(x$feature_abundances_in_total_units()),
x$zone_names())
expect_equal(rownames(x$feature_abundances_in_total_units()),
x$feature_names())
expect_equivalent(x$data$rij_matrix,
list(rij_matrix(sim_pu_raster, sim_features)))
expect_equal(names(x$data$rij_matrix), x$zone_names())
expect_equal(rownames(x$data$rij_matrix[[1]]), x$feature_names())
expect_error(x$feature_targets())
})
test_that("x=RasterStack, features=ZonesRaster", {
data(sim_pu_zones_stack, sim_features_zones)
sim_pu_zones_stack[] <- sim_pu_zones_stack[] *
runif(length(sim_pu_zones_stack[]), -1, 1)
sim_features_zones[[1]][] <- sim_features_zones[[1]][] *
runif(length(sim_features_zones[[1]][]), -1, 1)
expect_warning(x <- problem(sim_pu_zones_stack, sim_features_zones))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), feature_names(sim_features_zones))
expect_equal(x$zone_names(), zone_names(sim_features_zones))
expect_equal(x$number_of_features(), number_of_features(sim_features_zones))
expect_equal(x$number_of_zones(), number_of_zones(sim_features_zones))
expect_equal(x$number_of_planning_units(),
raster::cellStats(max(!is.na(sim_pu_zones_stack)), "sum"))
expect_equal(x$planning_unit_indices(),
raster::Which(max(!is.na(sim_pu_zones_stack)) > 0, cells = TRUE))
expect_equal(x$number_of_total_units(), raster::ncell(sim_pu_zones_stack))
expect_equivalent(x$planning_unit_costs(),
sim_pu_zones_stack[raster::Which(
max(!is.na(sim_pu_zones_stack)) == 1)])
expect_equal(colnames(x$planning_unit_costs()),
zone_names(sim_features_zones))
expect_equivalent(x$feature_abundances_in_planning_units(),
sapply(seq_len(raster::nlayers(sim_pu_zones_stack)), function(i) {
raster::cellStats(raster::mask(sim_features_zones[[i]],
sim_pu_zones_stack[[i]]), "sum")
}))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
zone_names(sim_features_zones))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
feature_names(sim_features_zones))
expect_equivalent(x$feature_abundances_in_total_units(),
sapply(seq_len(raster::nlayers(sim_pu_zones_stack)), function(i) {
raster::cellStats(sim_features_zones[[i]], "sum")
}))
expect_equal(colnames(x$feature_abundances_in_total_units()),
zone_names(sim_features_zones))
expect_equal(rownames(x$feature_abundances_in_total_units()),
feature_names(sim_features_zones))
expect_equivalent(x$data$rij_matrix,
lapply(seq_len(raster::nlayers(sim_pu_zones_stack)),
function(i) rij_matrix(sim_pu_zones_stack[[i]],
sim_features_zones[[i]])))
expect_equal(names(x$data$rij_matrix), zone_names(sim_features_zones))
expect_equivalent(sapply(x$data$rij_matrix, rownames),
matrix(feature_names(sim_features_zones),
ncol = number_of_zones(sim_features_zones),
nrow = number_of_features(sim_features_zones)))
expect_error(x$feature_targets())
})
test_that("x=SpatialPolygonsDataFrame, features=RasterStack", {
data(sim_pu_polygons, sim_features)
sim_pu_polygons$cost[1:5] <- NA
sim_pu_polygons$cost <- sim_pu_polygons$cost * runif(nrow(sim_pu_polygons),
-1, 1)
sim_features[] <- sim_features[] * runif(length(sim_features[]), -1, 1)
expect_warning(x <- problem(sim_pu_polygons, sim_features, "cost"))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), names(sim_features))
expect_equal(x$zone_names(), "cost")
expect_equal(x$number_of_features(), raster::nlayers(sim_features))
expect_equal(x$number_of_planning_units(), sum(!is.na(sim_pu_polygons$cost)))
expect_equal(x$planning_unit_indices(), which(!is.na(sim_pu_polygons$cost)))
expect_equal(x$number_of_total_units(), nrow(sim_pu_polygons))
expect_equivalent(x$planning_unit_costs(),
matrix(sim_pu_polygons$cost[!is.na(sim_pu_polygons$cost)],
ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), "cost")
expect_equivalent(x$feature_abundances_in_planning_units(),
Matrix::rowSums(x$data$rij_matrix[[1]]))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
"cost")
expect_equal(rownames(x$feature_abundances_in_planning_units()),
names(sim_features))
expect_lte(
max(abs(x$feature_abundances_in_total_units() -
colSums(exactextractr::exact_extract(
sim_features, sf::st_as_sf(sim_pu_polygons), "sum",
progress = FALSE)))),
1e-6)
expect_equal(colnames(x$feature_abundances_in_total_units()),
"cost")
expect_equal(rownames(x$feature_abundances_in_total_units()),
names(sim_features))
expect_equivalent(x$data$rij_matrix,
list(rij_matrix(sim_pu_polygons[
!is.na(sim_pu_polygons[[1]]), ], sim_features)))
expect_equal(names(x$data$rij_matrix), "cost")
expect_equal(rownames(x$data$rij_matrix[[1]]), names(sim_features))
expect_error(x$feature_targets())
})
test_that("x=SpatialPolygonsDataFrame, features=ZonesRaster", {
data(sim_pu_zones_polygons, sim_features_zones)
sim_pu_zones_polygons[5, paste0("cost_", 1:3)] <- NA
sim_pu_zones_polygons[4, "cost_1"] <- NA
sim_pu_zones_polygons$cost_1 <- sim_pu_zones_polygons$cost_1 *
runif(nrow(sim_pu_zones_polygons), -1, 1)
sim_features_zones[[1]][] <- sim_features_zones[[1]][] *
runif(length(sim_features_zones[[1]][]), -1, 1)
expect_warning(x <- problem(sim_pu_zones_polygons, sim_features_zones,
paste0("cost_", 1:3)))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), feature_names(sim_features_zones))
expect_equal(x$zone_names(), zone_names(sim_features_zones))
expect_equal(x$number_of_features(), raster::nlayers(sim_features_zones[[1]]))
expect_equal(x$number_of_planning_units(), nrow(sim_pu_zones_polygons) - 1)
expect_equal(x$planning_unit_indices(),
c(seq_len(4), seq(6, nrow(sim_pu_zones_polygons))))
expect_equal(x$number_of_total_units(), nrow(sim_pu_polygons))
expect_equivalent(x$planning_unit_costs(), as.matrix(
sim_pu_zones_polygons@data[-5, paste0("cost_", 1:3)]))
expect_equal(colnames(x$planning_unit_costs()),
zone_names(sim_features_zones))
expect_equivalent(x$feature_abundances_in_planning_units(),
sapply(seq_along(x$data$rij_matrix), function(i) {
pos1 <- x$planning_unit_indices()
pos2 <- which(!is.na(sim_pu_zones_polygons@data[[paste0("cost_", i)]]))
pos3 <- match(pos2, pos1)
Matrix::rowSums(x$data$rij_matrix[[i]][, pos3, drop = FALSE])
}))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
zone_names(sim_features_zones))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
feature_names(sim_features_zones))
expect_equivalent(x$feature_abundances_in_total_units(),
sapply(lapply(sim_features_zones, raster::extract,
sim_pu_zones_polygons, "sum",
na.rm = TRUE),
colSums, na.rm = TRUE))
expect_equal(colnames(x$feature_abundances_in_total_units()),
zone_names(sim_features_zones))
expect_equal(rownames(x$feature_abundances_in_total_units()),
feature_names(sim_features_zones))
expect_equivalent(x$data$rij_matrix,
lapply(sim_features_zones, rij_matrix,
x = sim_pu_zones_polygons[-5, ]))
expect_equal(names(x$data$rij_matrix), zone_names(sim_features_zones))
expect_equivalent(sapply(x$data$rij_matrix, rownames),
matrix(feature_names(sim_features_zones),
ncol = number_of_zones(sim_features_zones),
nrow = number_of_features(sim_features_zones)))
expect_error(x$feature_targets())
})
test_that("x=SpatialPolygonsDataFrame, features=character", {
data(sim_pu_polygons)
sim_pu_polygons$cost[2] <- NA
sim_pu_polygons$cost <- sim_pu_polygons$cost * runif(nrow(sim_pu_polygons),
-1, 1)
sim_pu_polygons$spp1 <- runif(length(sim_pu_polygons), -1, 1)
sim_pu_polygons$spp2 <- c(NA, rpois(length(sim_pu_polygons) - 1, 5) - 1)
expect_warning(x <- problem(sim_pu_polygons, c("spp1", "spp2"), "cost"))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("spp1", "spp2"))
expect_equal(x$zone_names(), "cost")
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 1)
expect_equal(x$number_of_planning_units(), length(sim_pu_polygons) - 1)
expect_equal(x$planning_unit_indices(), c(1, seq(3, length(sim_pu_polygons))))
expect_equal(x$number_of_total_units(), length(sim_pu_polygons))
expect_equivalent(x$planning_unit_costs(),
matrix(sim_pu_polygons$cost[-2], ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), "cost")
expect_equivalent(x$feature_abundances_in_planning_units(),
matrix(colSums(sim_pu_polygons@data[-2, c("spp1", "spp2")],
na.rm = TRUE), ncol = 1))
expect_equal(colnames(x$feature_abundances_in_planning_units()), "cost")
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("spp1", "spp2"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(colSums(sim_pu_polygons@data[, c("spp1", "spp2")],
na.rm = TRUE), ncol = 1))
expect_equal(colnames(x$feature_abundances_in_total_units()), "cost")
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("spp1", "spp2"))
rij <- Matrix::sparseMatrix(i = c(rep(1, length(sim_pu_polygons) - 1),
rep(2, length(sim_pu_polygons) - 2)),
j = c(seq_len(length(sim_pu_polygons) - 1),
seq_len(length(sim_pu_polygons) - 1)[-1]),
x = c(sim_pu_polygons$spp1[-2],
sim_pu_polygons$spp2[c(-1, -2)]),
dims = c(2, length(sim_pu_polygons) - 1))
rij <- list(rij)
expect_true(all(x$data$rij_matrix[[1]] == rij[[1]]))
expect_equal(names(x$data$rij_matrix), "cost")
expect_equal(rownames(x$data$rij_matrix[[1]]), c("spp1", "spp2"))
expect_error(x$feature_targets())
})
test_that("x=SpatialPolygonsDataFrame, features=ZonesCharacter", {
data(sim_pu_zones_polygons)
sim_pu_zones_polygons$cost_1[2] <- NA
sim_pu_zones_polygons[3, c("cost_1", "cost_2")] <- NA
sim_pu_zones_polygons$cost_1 <- sim_pu_zones_polygons$cost_1 *
runif(nrow(sim_pu_zones_polygons), -1, 1)
sim_pu_zones_polygons$spp1_1 <- runif(length(sim_pu_zones_polygons), -1, 1)
sim_pu_zones_polygons$spp2_1 <- c(NA, rpois(length(sim_pu_zones_polygons) - 1,
5))
sim_pu_zones_polygons$spp1_2 <- runif(length(sim_pu_zones_polygons), -1, 1)
sim_pu_zones_polygons$spp2_2 <- runif(length(sim_pu_zones_polygons), -1, 1)
sim_pu_zones_polygons <- sim_pu_zones_polygons[1:5, ]
expect_warning(x <- problem(sim_pu_zones_polygons,
zones(c("spp1_1", "spp2_1"),
c("spp1_2", "spp2_2"),
zone_names = c("z1", "z2"),
feature_names = c("spp1", "spp2")),
c("cost_1", "cost_2")))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("spp1", "spp2"))
expect_equal(x$zone_names(), c("z1", "z2"))
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 2)
expect_equal(x$number_of_planning_units(), length(sim_pu_zones_polygons) - 1)
expect_equal(x$planning_unit_indices(),
c(c(1, 2), seq(4, length(sim_pu_zones_polygons))))
expect_equal(x$number_of_total_units(), length(sim_pu_zones_polygons))
expect_equivalent(x$planning_unit_costs(),
as.matrix(sim_pu_zones_polygons@data[-3, c("cost_1",
"cost_2")]))
expect_equal(colnames(x$planning_unit_costs()), c("z1", "z2"))
expect_equivalent(
x$feature_abundances_in_planning_units(),
matrix(c(sum(sim_pu_zones_polygons$spp1_1[
!is.na(sim_pu_zones_polygons$cost_1)], na.rm = TRUE),
sum(sim_pu_zones_polygons$spp2_1[
!is.na(sim_pu_zones_polygons$cost_1)], na.rm = TRUE),
sum(sim_pu_zones_polygons$spp1_2[
!is.na(sim_pu_zones_polygons$cost_2)], na.rm = TRUE),
sum(sim_pu_zones_polygons$spp2_2[
!is.na(sim_pu_zones_polygons$cost_2)], na.rm = TRUE)),
ncol = 4))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
c("z1", "z2"))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("spp1", "spp2"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(colSums(sim_pu_zones_polygons@data[,
c("spp1_1", "spp2_1", "spp1_2", "spp2_2")], na.rm = TRUE), ncol = 2))
expect_equal(colnames(x$feature_abundances_in_total_units()),
c("z1", "z2"))
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("spp1", "spp2"))
r1 <- Matrix::sparseMatrix(i = c(rep(1, length(sim_pu_zones_polygons) - 1),
rep(2, length(sim_pu_zones_polygons) - 2)),
j = c(seq_len(length(sim_pu_zones_polygons) - 1),
seq_len(length(sim_pu_zones_polygons) -
1)[-1]),
x = c(sim_pu_zones_polygons$spp1_1[-3],
sim_pu_zones_polygons$spp2_1[c(-1, -3)]),
dims = c(2, length(sim_pu_zones_polygons) - 1))
r2 <- Matrix::sparseMatrix(i = c(rep(1, length(sim_pu_zones_polygons) - 1),
rep(2, length(sim_pu_zones_polygons) - 1)),
j = c(seq_len(length(sim_pu_zones_polygons) - 1),
seq_len(length(sim_pu_zones_polygons) - 1)),
x = c(sim_pu_zones_polygons$spp1_2[-3],
sim_pu_zones_polygons$spp2_2[-3]),
dims = c(2, length(sim_pu_zones_polygons) - 1))
rij <- list(r1, r2)
expect_equal(names(x$data$rij_matrix), c("z1", "z2"))
expect_true(all(x$data$rij_matrix[[1]] == rij[[1]]))
expect_true(all(x$data$rij_matrix[[2]] == rij[[2]]))
expect_error(x$feature_targets())
})
test_that("x=data.frame, features=character", {
pu <- data.frame(id = seq_len(10), cost = c(runif(1), NA, runif(8, -1, 1)),
spp1 = runif(10, -1, 1), spp2 = c(rpois(9, 4), NA))
expect_warning(x <- problem(pu, c("spp1", "spp2"), "cost"))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("spp1", "spp2"))
expect_equal(x$zone_names(), "cost")
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 1)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), which(!is.na(pu$cost)))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(), matrix(pu$cost[-2], ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), "cost")
expect_equivalent(x$feature_abundances_in_planning_units(),
matrix(colSums(pu[-2, c("spp1", "spp2")], na.rm = TRUE),
ncol = 1))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
c("cost"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(colSums(pu[, c("spp1", "spp2")], na.rm = TRUE),
ncol = 1))
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_total_units()),
c("cost"))
expect_true(all(x$data$rij_matrix[[1]] ==
Matrix::sparseMatrix(i = c(rep(1, 9), rep(2, 8)),
j = c(1:9, 1:8),
x = c(pu$spp1[-2], pu$spp2[c(-2, -10)]),
dims = c(2, 9))))
expect_equal(names(x$data$rij_matrix), "cost")
expect_equal(rownames(x$data$rij_matrix[[1]]), c("spp1", "spp2"))
expect_error(x$feature_targets())
})
test_that("x=data.frame, features=ZonesCharacter", {
pu <- data.frame(id = seq_len(10), cost_1 = c(NA, NA, runif(8)),
cost_2 = c(0.3, NA, runif(8)),
spp1_1 = runif(10, -1, 1), spp2_1 = c(rpois(9, 4), NA),
spp1_2 = runif(10, -1, 1), spp2_2 = runif(10, -1, 1))
expect_warning(x <- problem(pu,
zones(c("spp1_1", "spp2_1"),
c("spp1_2", "spp2_2")),
c("cost_1", "cost_2")))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("1", "2"))
expect_equal(x$zone_names(), c("1", "2"))
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 2)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), c(1, seq(3, nrow(pu))))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(), as.matrix(pu[-2, 2:3]))
expect_equal(colnames(x$planning_unit_costs()), c("1", "2"))
expect_equivalent(
x$feature_abundances_in_planning_units(),
matrix(c(sum(pu$spp1_1[!is.na(pu$cost_1)], na.rm = TRUE),
sum(pu$spp2_1[!is.na(pu$cost_1)], na.rm = TRUE),
sum(pu$spp1_2[!is.na(pu$cost_2)], na.rm = TRUE),
sum(pu$spp2_2[!is.na(pu$cost_2)], na.rm = TRUE)),
ncol = 4))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("1", "2"))
expect_equal(colnames(x$feature_abundances_in_planning_units()),
c("1", "2"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(colSums(pu[, 4:7], na.rm = TRUE), ncol = 2))
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("1", "2"))
expect_equal(colnames(x$feature_abundances_in_total_units()),
c("1", "2"))
expect_equal(names(x$data$rij_matrix), c("1", "2"))
expect_true(all(x$data$rij_matrix[[1]] ==
Matrix::sparseMatrix(i = c(rep(1, 9), rep(2, 8)),
j = c(1:9, 1:8),
x = c(pu$spp1_1[-2],
pu$spp2_1[c(-2, -10)]),
dims = c(2, 9))))
expect_true(all(x$data$rij_matrix[[2]] ==
Matrix::sparseMatrix(i = c(rep(1, 9), rep(2, 9)),
j = c(1:9, 1:9),
x = c(pu$spp1_2[-2], pu$spp2_2[-2]),
dims = c(2, 9))))
expect_equal(names(x$data$rij_matrix), c("1", "2"))
expect_equal(rownames(x$data$rij_matrix[[1]]), c("1", "2"))
expect_equal(rownames(x$data$rij_matrix[[2]]), c("1", "2"))
expect_error(x$feature_targets())
})
test_that("x=data.frame, features=data.frame (single zone)", {
pu <- data.frame(id = seq_len(10), cost = c(0.1, NA, runif(8, -1, 1)))
species <- data.frame(id = seq_len(5), name = letters[1:5], targets = 0.5)
rij <- expand.grid(pu = seq_len(9), species = seq_len(5))
rij$amount <- runif(nrow(rij), -1, 1)
expect_warning(x <- problem(pu, species, rij, "cost"))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), letters[1:5])
expect_equal(x$zone_names(), "cost")
expect_equal(x$number_of_features(), 5)
expect_equal(x$number_of_zones(), 1)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), which(!is.na(pu$cost)))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(), matrix(pu$cost[-2], ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), "cost")
rij2 <- rij[rij$pu != 2, ]
expect_equivalent(x$feature_abundances_in_planning_units(),
Matrix::rowSums(Matrix::sparseMatrix(i = rij2[[2]],
j = rij2[[1]],
x = rij2[[3]])))
expect_equal(rownames(x$feature_abundances_in_planning_units()), letters[1:5])
expect_equal(colnames(x$feature_abundances_in_planning_units()), "cost")
expect_equivalent(x$feature_abundances_in_total_units(),
Matrix::rowSums(Matrix::sparseMatrix(i = rij[[2]],
j = rij[[1]],
x = rij[[3]])))
expect_equal(rownames(x$feature_abundances_in_total_units()), letters[1:5])
expect_equal(colnames(x$feature_abundances_in_total_units()), "cost")
rij2 <- rij[rij$pu != 2, ]
rij2$pu <- match(rij2$pu, pu$id[-2])
expect_equivalent(x$data$rij_matrix[[1]],
Matrix::sparseMatrix(i = rij2[[2]], j = rij2[[1]],
x = rij2[[3]],
dims = c(5, 9)))
expect_equal(names(x$data$rij_matrix), "cost")
expect_equal(rownames(x$data$rij_matrix[[1]]), letters[1:5])
expect_error(x$feature_targets())
})
test_that("x=data.frame, features=data.frame (multiple zones)", {
pu <- data.frame(id = seq_len(10), cost_1 = c(0.1, NA, runif(8, -1, 1)),
cost_2 = c(NA, NA, runif(8, -1, 1)))
species <- data.frame(id = seq_len(5), name = letters[1:5], targets = 0.5)
rij <- expand.grid(pu = seq_len(9), species = seq_len(5), zone = 1:2)
rij$amount <- runif(nrow(rij), -1, 1)
z <- data.frame(id = 1:2, name = c("z1", "z2"))
expect_warning(x <- problem(pu, species, rij, c("cost_1", "cost_2"), z))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), letters[1:5])
expect_equal(x$zone_names(), c("z1", "z2"))
expect_equal(x$number_of_features(), 5)
expect_equal(x$number_of_zones(), 2)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), c(1, seq(3, nrow(pu))))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(), as.matrix(pu[-2, 2:3]))
expect_equal(colnames(x$planning_unit_costs()), c("z1", "z2"))
rij2 <- rij
rij2 <- rij2[!(rij2$pu %in% pu$id[is.na(pu$cost_1)] & rij2$zone == 1), ]
rij2 <- rij2[!(rij2$pu %in% pu$id[is.na(pu$cost_2)] & rij2$zone == 2), ]
expect_equivalent(x$feature_abundances_in_planning_units(),
matrix(aggregate(rij2[[4]], by = list(rij2[[2]], rij2[[3]]),
sum)[[3]], ncol = 2))
expect_equal(rownames(x$feature_abundances_in_planning_units()), letters[1:5])
expect_equal(colnames(x$feature_abundances_in_planning_units()),
c("z1", "z2"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(aggregate(rij[[4]], by = list(rij[[2]], rij[[3]]),
sum)[[3]], ncol = 2))
expect_equal(rownames(x$feature_abundances_in_total_units()), letters[1:5])
expect_equal(colnames(x$feature_abundances_in_total_units()),
c("z1", "z2"))
rij2 <- rij[rij$pu != 2, ]
rij2$pu <- match(rij2$pu, seq_len(9))
expect_equal(names(x$data$rij_matrix), c("z1", "z2"))
expect_equivalent(x$data$rij_matrix[[1]],
Matrix::sparseMatrix(i = rij2[[2]][rij2[[3]] == 1],
j = rij2[[1]][rij2[[3]] == 1],
x = rij2[[4]][rij2[[3]] == 1],
dims = c(5, 9)))
expect_equivalent(x$data$rij_matrix[[2]],
Matrix::sparseMatrix(i = rij2[[2]][rij2[[3]] == 2],
j = rij2[[1]][rij2[[3]] == 2],
x = rij2[[4]][rij2[[3]] == 2],
dims = c(5, 9)))
expect_equal(rownames(x$data$rij_matrix[[1]]), letters[1:5])
expect_equal(rownames(x$data$rij_matrix[[2]]), letters[1:5])
expect_error(x$feature_targets())
})
test_that("x=numeric, features=data.frame", {
pu <- data.frame(id = seq_len(10), cost = c(0.2, NA, runif(8, -1, 1)),
spp1 = runif(10, -1, 1), spp2 = c(rpois(9, 4), NA))
expect_warning(x <- problem(pu$cost,
data.frame(id = seq_len(2),
name = c("spp1", "spp2")),
as.matrix(t(pu[, 3:4]))))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("spp1", "spp2"))
expect_equal(x$zone_names(), "1")
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 1)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), which(!is.na(pu$cost)))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(),
matrix(pu$cost[-2], ncol = 1))
expect_equal(colnames(x$planning_unit_costs()), "1")
expect_equivalent(x$feature_abundances_in_planning_units(),
rowSums(t(pu[-2, 3:4]), na.rm = TRUE))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_planning_units()), "1")
expect_equivalent(x$feature_abundances_in_total_units(),
rowSums(t(pu[, 3:4]), na.rm = TRUE))
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_total_units()), "1")
expect_equal(names(x$data$rij_matrix), "1")
expect_equivalent(x$data$rij_matrix[[1]],
as(t(pu[-2, 3:4]), "sparseMatrix"))
expect_equal(rownames(x$data$rij_matrix[[1]]), c("spp1", "spp2"))
expect_error(x$feature_targets())
})
test_that("x=matrix, features=data.frame", {
pu <- data.frame(id = seq_len(10), cost_1 = c(NA, NA, runif(8, -1, 1)),
cost_2 = c(0.3, NA, runif(8, -1, 1)),
spp1_1 = runif(10, -1, 1), spp2_1 = c(rpois(9, 4), NA),
spp1_2 = runif(10, -1, 1), spp2_2 = runif(10, -1, 1))
expect_warning(x <- problem(as.matrix(pu[, 2:3]),
data.frame(id = seq_len(2),
name = c("spp1", "spp2")),
list(as.matrix(t(pu[, 4:5])),
as.matrix(t(pu[, 6:7])))))
suppressMessages(print(x))
suppressMessages(x)
expect_equal(x$feature_names(), c("spp1", "spp2"))
expect_equal(x$zone_names(), c("1", "2"))
expect_equal(x$number_of_features(), 2)
expect_equal(x$number_of_zones(), 2)
expect_equal(x$number_of_planning_units(), 9)
expect_equal(x$planning_unit_indices(), c(1, seq(3, nrow(pu))))
expect_equal(x$number_of_total_units(), 10)
expect_equivalent(x$planning_unit_costs(),
as.matrix(pu[-2, 2:3]))
expect_equal(colnames(x$planning_unit_costs()), c("1", "2"))
expect_equivalent(
x$feature_abundances_in_planning_units(),
matrix(c(sum(pu$spp1_1[!is.na(pu$cost_1)], na.rm = TRUE),
sum(pu$spp2_1[!is.na(pu$cost_1)], na.rm = TRUE),
sum(pu$spp1_2[!is.na(pu$cost_2)], na.rm = TRUE),
sum(pu$spp2_2[!is.na(pu$cost_2)], na.rm = TRUE)),
ncol = 4))
expect_equal(rownames(x$feature_abundances_in_planning_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_planning_units()), c("1", "2"))
expect_equivalent(x$feature_abundances_in_total_units(),
matrix(colSums(pu[, 4:7], na.rm = TRUE), ncol = 2))
expect_equal(rownames(x$feature_abundances_in_total_units()),
c("spp1", "spp2"))
expect_equal(colnames(x$feature_abundances_in_total_units()), c("1", "2"))
expect_equal(names(x$data$rij_matrix), c("1", "2"))
expect_equivalent(x$data$rij_matrix[[1]],
as(t(pu[-2, 4:5]), "sparseMatrix"))
expect_equivalent(x$data$rij_matrix[[2]],
as(t(pu[-2, 6:7]), "sparseMatrix"))
expect_equal(rownames(x$data$rij_matrix[[1]]), c("spp1", "spp2"))
expect_equal(rownames(x$data$rij_matrix[[2]]), c("spp1", "spp2"))
expect_error(x$feature_targets())
})
|
Neighboot<- function(RDS.data, quant=c(0.025, 0.975),method=c("percentile","Wald"), B=1000) {
p.est<-apply((RDS.data$traits/RDS.data$degree)/sum(1/RDS.data$degree),2,sum,na.rm=TRUE)
resamp <- .Nb(RDS.data, B)
results <- matrix(NA, dim(RDS.data$traits)[2], (length(quant)+1))
method <- match.arg(method)
for(t in 1:dim(RDS.data$traits)[2]) {
p.TBS <- sapply(resamp, .propvh, RDS.data$traits[,t], RDS.data$degree)
results[t,1] <- sd(p.TBS,na.rm = TRUE)
for(q in 2:(length(quant)+1)){
if(method%in%c("percentile")){
results[t,q] <- quantile(p.TBS,quant[q-1],na.rm=TRUE)
}else if(method%in%c("studentized")){
results[t,q]<-p.est[t]+qt(quant[q-1],dim(RDS.data$traits)[2]-1)*results[t,1]
}else{
stop("The method is invalid.")
}
}
}
rownames(results) <- colnames(RDS.data$traits)
colnames(results) <- c("SE",quant)
return(results)
}
.propvh<- function(RDS.data, trait, dg) sum(trait[RDS.data]/dg[RDS.data], na.rm=T)/sum((!is.na(trait[RDS.data]))/dg[RDS.data])
.Nb<- function(RDS.data, B) {
RDS.gr<-igraph::graph_from_data_frame(RDS.data$edges, directed = F, vertices = cbind(id=1:length(RDS.data$traits[,2]),RDS.data$traits))
e.deg<-igraph::degree(RDS.gr,mode="total")
cr<-mean(e.deg)
resamp <- list()
sz<-round(length(RDS.data$traits[,2])/cr)
for(b in 1:B) {
xx.s<-sample(1:length(RDS.data$traits[,2]),size=sz,replace=TRUE)
x.neig<-as.numeric(unlist(igraph::ego(
RDS.gr,
order = 1,
nodes = xx.s,
mode = "all",
mindist = 1
)))
resamp[[b]]<-x.neig
}
return(resamp)
}
|
score.biprobit <- function(x,indiv=FALSE,...) {
if (indiv) { s <- x$score; attributes(s)$logLik <- NULL; return(s) }
colSums(x$score)
}
|
context("ErrorModule")
test_that("ErrorModule works.", {
expect_error(ErrorModule("esv", 1, environment()),
"Stopping workflow due to error in")
expect_false(exists("tmpZoonWorkflow"))
})
|
file.backup <- function(name, fullpath = FALSE, keep.old = FALSE, verbose = FALSE){
if(!file.exists(name)){
MESSG <- paste("file", name, "does not exist. No backup created.")
if(verbose) warning(MESSG)
return(NULL)
}
dir.source <- dirname(normalizePath(name))
date_cr <- base::format(base::file.info(name)$mtime, "%Y%m%d-%H%M")
ext_name <- tools::file_ext(name)
noext_name <- tools::file_path_sans_ext(name)
new_name <- paste0(noext_name, "-", date_cr,
if(!ext_name == "") {paste0( ".", ext_name)})
if (file.exists(new_name)){
MESSG <- paste("backup file already exists. No new backup created.")
if(verbose) warning(MESSG)
return(new_name)
}
ret <- if(keep.old){
file.copy(name, new_name, overwrite = TRUE,
copy.mode = TRUE, copy.date = TRUE)
}else{
file.rename(name, new_name)
}
if(!ret) {
MESSG <- paste("file.rename(", name, ",", new_name, "failed")
stop(MESSG)
}
if(verbose){
cat("File list of:", dir.source, "\n")
print(list.files(dir.source))
cat("End of file list\n")
}
if(fullpath){
new_name_fullpath <- normalizePath(new_name)
return(new_name_fullpath)
}
new_name
}
|
recover_data = function(object, ...) {
for (cl in .chk.cls(object)) {
rd <- .get.outside.method("recover_data", cl)
if(!is.null(rd))
return(rd(object, ...))
}
UseMethod("recover_data")
}
.chk.cls = function(object) {
sacred = c("call", "lm", "glm", "mlm", "aovlist", "lme", "qdrg")
setdiff(class(object)[1:2], sacred)
}
.get.outside.method = function(generic, cls) {
mth = utils::getAnywhere(paste(generic, cls, sep = "."))
from = sapply(strsplit(mth[[3]], "[ :]"), function(x) rev(x)[1])
if (length(from) == 0)
return (NULL)
if(any(outside <- (from != "emmeans")))
mth[which(outside)[1]]
else
NULL
}
recover_data.call = function(object, trms, na.action, data = NULL, params = "pi", frame, ...) {
fcall = object
vars = setdiff(.all.vars(trms), params)
if (!missing(frame) && is.null(data) && !.has.fcns(trms))
data = frame
tbl = data
if (length(vars) == 0 || vars[1] == "1") {
tbl = data.frame(c(1,1))
vars = names(tbl) = 1
}
if (is.null(tbl)) {
possibly.random = FALSE
m = match(c("formula", "data", "subset", "weights"), names(fcall), 0L)
fcall = fcall[c(1L, m)]
mm = match(c("data", "subset"), names(fcall), 0L)
if(any(mm > 0)) {
fcns = unlist(lapply(fcall[mm],
function(x) setdiff(all.names(x),
c("::",":::","[[","]]",all.vars(x)))))
possibly.random = (max(nchar(c("", fcns))) > 1)
}
fcall$drop.unused.levels = TRUE
fcall[[1L]] = quote(stats::model.frame)
fcall$xlev = NULL
if(!is.numeric(na.action))
na.action = NULL
if (!is.null(na.action))
fcall$na.action = na.pass
else
fcall$na.action = na.omit
form = .reformulate(vars)
fcall$formula = update(trms, form)
env = environment(trms)
if (is.null(env))
env = parent.frame()
tbl = try(eval(fcall, env, parent.frame()), silent = TRUE)
if(inherits(tbl, "try-error"))
return(.rd.error(vars, fcall))
if (possibly.random) {
chk = eval(fcall, env, parent.frame())
if (!all(chk == tbl))
stop("Data appear to be randomized -- ",
"cannot consistently recover the data\n",
"Move the randomization ",
"outside of the model-fitting call.")
}
if (!is.null(na.action))
tbl = tbl[-(na.action), , drop=FALSE]
}
else {
tbl = tbl[, vars, drop = FALSE]
tbl = tbl[complete.cases(tbl), , drop=FALSE]
}
attr(tbl, "call") = object
attr(tbl, "terms") = trms
attr(tbl, "predictors") = setdiff(.all.vars(delete.response(trms)), params)
attr(tbl, "responses") = setdiff(vars, union(attr(tbl, "predictors"), params))
tbl
}
.rd.error = function(vars, fcall) {
if ("pi" %in% vars)
return("\nTry re-running with 'params = c\"pi\", ...)'")
if (is.list(fcall$data)) fcall$data = "(raw data structure)"
dataname = as.character(fcall$data)[1]
if ((!is.na(dataname)) && (nchar(dataname) > 50))
dataname = paste(substring(dataname, 1, 50), "...")
mesg = "We are unable to reconstruct the data.\n"
mesg = paste0(mesg, "The variables needed are:\n\t",
paste(vars, collapse = " "), "\n",
"Are any of these actually constants? (specify via 'params = ')\n")
if (is.na(dataname))
mesg = paste(mesg, "Try re-running with 'data = \"<name of dataset>\"'\n")
else
mesg = paste0(mesg, "The dataset name is:\n\t", dataname, "\n",
"Does the data still exist? Or you can specify a dataset via 'data = '\n")
mesg
}
emm_basis = function(object, trms, xlev, grid, ...) {
for (cl in .chk.cls(object)) {
emb <- .get.outside.method("emm_basis", cl)
if(!is.null(emb))
return(emb(object, trms, xlev, grid, ...))
}
UseMethod("emm_basis")
}
.recover_data = function(object, ...)
recover_data(object, ...)
.emm_basis = function(object, trms, xlev, grid, ...)
emm_basis(object, trms, xlev, grid, ...)
recover_data.default = function(object, ...) {
paste("Can't handle an object of class ", dQuote(class(object)[1]), "\n",
paste(.show_supported(), collapse=""))
}
emm_basis.default = function(object, trms, xlev, grid, ...) {
stop("Can't handle an object of class", dQuote(class(object)[1]), "\n",
.show_supported())
}
.show_supported = function(ns = "emmeans", meth = "emm_basis") {
"Use help(\"models\", package = \"emmeans\") for information on supported models."
}
|
expected <- eval(parse(text="NA_real_"));
test(id=0, code={
argv <- eval(parse(text="list(structure(list(Df = 10L, `Sum Sq` = 2.74035772634541, `Mean Sq` = 0.274035772634541, `F value` = NA_real_, `Pr(>F)` = NA_real_), .Names = c(\"Df\", \"Sum Sq\", \"Mean Sq\", \"F value\", \"Pr(>F)\"), row.names = \"Residuals\", class = c(\"anova\", \"data.frame\"), heading = c(\"Analysis of Variance Table\\n\", \"Response: y\")), 5L)"));
do.call(`.subset2`, argv);
}, o=expected);
|
calculate_player_stats <- function(pbp, weekly = FALSE) {
mult_lats <- nflreadr::rds_from_url("https://github.com/mrcaseb/nfl-data/raw/master/data/lateral_yards/multiple_lateral_yards.rds") %>%
dplyr::mutate(
season = substr(.data$game_id, 1, 4) %>% as.integer(),
week = substr(.data$game_id, 6, 7) %>% as.integer()
) %>%
dplyr::filter(.data$yards != 0) %>%
dplyr::group_by(.data$game_id, .data$play_id) %>%
dplyr::slice(seq_len(dplyr::n() - 1)) %>%
dplyr::ungroup() %>%
dplyr::group_by(.data$season, .data$week, .data$type, .data$gsis_player_id) %>%
dplyr::summarise(yards = sum(.data$yards)) %>%
dplyr::ungroup()
suppressMessages({
data <- pbp %>%
dplyr::filter(
!is.na(.data$down),
.data$play_type %in% c("pass", "qb_kneel", "qb_spike", "run")
) %>%
decode_player_ids()
if (!"qb_epa" %in% names(data)) data <- add_qb_epa(data)
two_points <- pbp %>%
dplyr::filter(.data$two_point_conv_result == "success") %>%
dplyr::select(
"week", "season", "posteam",
"pass_attempt", "rush_attempt",
"passer_player_name", "passer_player_id",
"rusher_player_name", "rusher_player_id",
"lateral_rusher_player_name", "lateral_rusher_player_id",
"receiver_player_name", "receiver_player_id",
"lateral_receiver_player_name", "lateral_receiver_player_id"
) %>%
decode_player_ids()
})
if (!"special" %in% names(pbp)) {
pbp <- pbp %>%
dplyr::mutate(
special = dplyr::if_else(
.data$play_type %in% c("extra_point","field_goal","kickoff","punt"),
1, 0
)
)
}
s_type <- pbp %>%
dplyr::select(.data$season, .data$season_type, .data$week) %>%
dplyr::distinct()
racr_ids <- nflreadr::qs_from_url("https://github.com/nflverse/nflfastR-roster/raw/master/data/nflfastR-RB_ids.qs")
pass_df <- data %>%
dplyr::filter(.data$play_type %in% c("pass", "qb_spike")) %>%
dplyr::group_by(.data$passer_player_id, .data$week, .data$season) %>%
dplyr::summarize(
passing_yards_after_catch = sum((.data$passing_yards - .data$air_yards) * .data$complete_pass, na.rm = TRUE),
name_pass = dplyr::first(.data$passer_player_name),
team_pass = dplyr::first(.data$posteam),
passing_yards = sum(.data$passing_yards, na.rm = TRUE),
passing_tds = sum(.data$touchdown == 1 & .data$td_team == .data$posteam & .data$complete_pass == 1),
interceptions = sum(.data$interception),
attempts = sum(.data$complete_pass == 1 | .data$incomplete_pass == 1 | .data$interception == 1),
completions = sum(.data$complete_pass == 1),
sack_fumbles = sum(.data$fumble == 1 & .data$fumbled_1_player_id == .data$passer_player_id),
sack_fumbles_lost = sum(.data$fumble_lost == 1 & .data$fumbled_1_player_id == .data$passer_player_id),
passing_air_yards = sum(.data$air_yards, na.rm = TRUE),
sacks = sum(.data$sack),
sack_yards = -1*sum(.data$yards_gained * .data$sack),
passing_first_downs = sum(.data$first_down_pass),
passing_epa = sum(.data$qb_epa, na.rm = TRUE),
pacr = .data$passing_yards / .data$passing_air_yards,
pacr = dplyr::case_when(
is.nan(.data$pacr) ~ NA_real_,
.data$passing_air_yards <= 0 ~ 0,
TRUE ~ .data$pacr
),
) %>%
dplyr::rename(player_id = .data$passer_player_id) %>%
dplyr::ungroup()
if (isTRUE(weekly)) pass_df <- add_dakota(pass_df, pbp = pbp, weekly = weekly)
pass_two_points <- two_points %>%
dplyr::filter(.data$pass_attempt == 1) %>%
dplyr::group_by(.data$passer_player_id, .data$week, .data$season) %>%
dplyr::summarise(
name_pass = custom_mode(.data$passer_player_name),
team_pass = custom_mode(.data$posteam),
passing_2pt_conversions = dplyr::n()
) %>%
dplyr::rename(player_id = .data$passer_player_id) %>%
dplyr::ungroup()
pass_df <- pass_df %>%
dplyr::full_join(pass_two_points, by = c("player_id", "week", "season", "name_pass", "team_pass")) %>%
dplyr::mutate(passing_2pt_conversions = dplyr::if_else(is.na(.data$passing_2pt_conversions), 0L, .data$passing_2pt_conversions)) %>%
dplyr::filter(!is.na(.data$player_id))
pass_df_nas <- is.na(pass_df)
epa_index <- which(dimnames(pass_df_nas)[[2]] %in% c("passing_epa", "dakota", "pacr"))
pass_df_nas[,epa_index] <- c(FALSE)
pass_df[pass_df_nas] <- 0
rushes <- data %>%
dplyr::filter(.data$play_type %in% c("run", "qb_kneel")) %>%
dplyr::group_by(.data$rusher_player_id, .data$week, .data$season) %>%
dplyr::summarize(
name_rush = dplyr::first(.data$rusher_player_name),
team_rush = dplyr::first(.data$posteam),
yards = sum(.data$rushing_yards, na.rm = TRUE),
tds = sum(.data$td_player_id == .data$rusher_player_id, na.rm = TRUE),
carries = dplyr::n(),
rushing_fumbles = sum(.data$fumble == 1 & .data$fumbled_1_player_id == .data$rusher_player_id & is.na(.data$lateral_rusher_player_id)),
rushing_fumbles_lost = sum(.data$fumble_lost == 1 & .data$fumbled_1_player_id == .data$rusher_player_id & is.na(.data$lateral_rusher_player_id)),
rushing_first_downs = sum(.data$first_down_rush & is.na(.data$lateral_rusher_player_id)),
rushing_epa = sum(.data$epa, na.rm = TRUE)
) %>%
dplyr::ungroup()
laterals <- data %>%
dplyr::filter(!is.na(.data$lateral_rusher_player_id)) %>%
dplyr::group_by(.data$lateral_rusher_player_id, .data$week, .data$season) %>%
dplyr::summarize(
lateral_yards = sum(.data$lateral_rushing_yards, na.rm = TRUE),
lateral_fds = sum(.data$first_down_rush, na.rm = TRUE),
lateral_tds = sum(.data$td_player_id == .data$lateral_rusher_player_id, na.rm = TRUE),
lateral_att = dplyr::n(),
lateral_fumbles = sum(.data$fumble, na.rm = TRUE),
lateral_fumbles_lost = sum(.data$fumble_lost, na.rm = TRUE)
) %>%
dplyr::ungroup() %>%
dplyr::rename(rusher_player_id = .data$lateral_rusher_player_id) %>%
dplyr::bind_rows(
mult_lats %>%
dplyr::filter(
.data$type == "lateral_rushing" & .data$season %in% data$season & .data$week %in% data$week
) %>%
dplyr::select("season", "week", "rusher_player_id" = .data$gsis_player_id, "lateral_yards" = .data$yards) %>%
dplyr::mutate(lateral_tds = 0L, lateral_att = 1L)
) %>%
dplyr::group_by(.data$rusher_player_id, .data$week, .data$season) %>%
dplyr::summarise_all(.funs = sum, na.rm = TRUE) %>%
dplyr::ungroup()
rush_df <- rushes %>%
dplyr::left_join(laterals, by = c("rusher_player_id", "week", "season")) %>%
dplyr::mutate(
lateral_yards = dplyr::if_else(is.na(.data$lateral_yards), 0, .data$lateral_yards),
lateral_tds = dplyr::if_else(is.na(.data$lateral_tds), 0L, .data$lateral_tds),
lateral_fumbles = dplyr::if_else(is.na(.data$lateral_fumbles), 0, .data$lateral_fumbles),
lateral_fumbles_lost = dplyr::if_else(is.na(.data$lateral_fumbles_lost), 0, .data$lateral_fumbles_lost),
lateral_fds = dplyr::if_else(is.na(.data$lateral_fds), 0, .data$lateral_fds)
) %>%
dplyr::mutate(
rushing_yards = .data$yards + .data$lateral_yards,
rushing_tds = .data$tds + .data$lateral_tds,
rushing_first_downs = .data$rushing_first_downs + .data$lateral_fds,
rushing_fumbles = .data$rushing_fumbles + .data$lateral_fumbles,
rushing_fumbles_lost = .data$rushing_fumbles_lost + .data$lateral_fumbles_lost
) %>%
dplyr::rename(player_id = .data$rusher_player_id) %>%
dplyr::select("player_id", "week", "season", "name_rush", "team_rush",
"rushing_yards", "carries", "rushing_tds", "rushing_fumbles",
"rushing_fumbles_lost", "rushing_first_downs", "rushing_epa") %>%
dplyr::ungroup()
rush_two_points <- two_points %>%
dplyr::filter(.data$rush_attempt == 1) %>%
dplyr::group_by(.data$rusher_player_id, .data$week, .data$season) %>%
dplyr::summarise(
name_rush = custom_mode(.data$rusher_player_name),
team_rush = custom_mode(.data$posteam),
rushing_2pt_conversions = dplyr::n()
) %>%
dplyr::rename(player_id = .data$rusher_player_id) %>%
dplyr::ungroup()
rush_df <- rush_df %>%
dplyr::full_join(rush_two_points, by = c("player_id", "week", "season", "name_rush", "team_rush")) %>%
dplyr::mutate(rushing_2pt_conversions = dplyr::if_else(is.na(.data$rushing_2pt_conversions), 0L, .data$rushing_2pt_conversions)) %>%
dplyr::filter(!is.na(.data$player_id))
rush_df_nas <- is.na(rush_df)
epa_index <- which(dimnames(rush_df_nas)[[2]] == "rushing_epa")
rush_df_nas[,epa_index] <- c(FALSE)
rush_df[rush_df_nas] <- 0
rec <- data %>%
dplyr::filter(!is.na(.data$receiver_player_id)) %>%
dplyr::group_by(.data$receiver_player_id, .data$week, .data$season) %>%
dplyr::summarize(
name_receiver = dplyr::first(.data$receiver_player_name),
team_receiver = dplyr::first(.data$posteam),
yards = sum(.data$receiving_yards, na.rm = TRUE),
receptions = sum(.data$complete_pass == 1),
targets = dplyr::n(),
tds = sum(.data$td_player_id == .data$receiver_player_id, na.rm = TRUE),
receiving_fumbles = sum(.data$fumble == 1 & .data$fumbled_1_player_id == .data$receiver_player_id & is.na(.data$lateral_receiver_player_id)),
receiving_fumbles_lost = sum(.data$fumble_lost == 1 & .data$fumbled_1_player_id == .data$receiver_player_id & is.na(.data$lateral_receiver_player_id)),
receiving_air_yards = sum(.data$air_yards, na.rm = TRUE),
receiving_yards_after_catch = sum(.data$yards_after_catch, na.rm = TRUE),
receiving_first_downs = sum(.data$first_down_pass & is.na(.data$lateral_receiver_player_id)),
receiving_epa = sum(.data$epa, na.rm = TRUE)
) %>%
dplyr::ungroup()
laterals <- data %>%
dplyr::filter(!is.na(.data$lateral_receiver_player_id)) %>%
dplyr::group_by(.data$lateral_receiver_player_id, .data$week, .data$season) %>%
dplyr::summarize(
lateral_yards = sum(.data$lateral_receiving_yards, na.rm = TRUE),
lateral_tds = sum(.data$td_player_id == .data$lateral_receiver_player_id, na.rm = TRUE),
lateral_att = dplyr::n(),
lateral_fds = sum(.data$first_down_pass, na.rm = T),
lateral_fumbles = sum(.data$fumble, na.rm = T),
lateral_fumbles_lost = sum(.data$fumble_lost, na.rm = T)
) %>%
dplyr::ungroup() %>%
dplyr::rename(receiver_player_id = .data$lateral_receiver_player_id) %>%
dplyr::bind_rows(
mult_lats %>%
dplyr::filter(
.data$type == "lateral_receiving" & .data$season %in% data$season & .data$week %in% data$week
) %>%
dplyr::select("season", "week", "receiver_player_id" = .data$gsis_player_id, "lateral_yards" = .data$yards) %>%
dplyr::mutate(lateral_tds = 0L, lateral_att = 1L)
) %>%
dplyr::group_by(.data$receiver_player_id, .data$week, .data$season) %>%
dplyr::summarise_all(.funs = sum, na.rm = TRUE) %>%
dplyr::ungroup()
rec_team <- data %>%
dplyr::filter(!is.na(.data$receiver_player_id)) %>%
dplyr::group_by(.data$posteam, .data$week, .data$season) %>%
dplyr::summarize(
team_targets = dplyr::n(),
team_air_yards = sum(.data$air_yards, na.rm = TRUE),
) %>%
dplyr::ungroup()
rec_df <- rec %>%
dplyr::left_join(laterals, by = c("receiver_player_id", "week", "season")) %>%
dplyr::left_join(rec_team, by = c("team_receiver" = "posteam", "week", "season")) %>%
dplyr::mutate(
lateral_yards = dplyr::if_else(is.na(.data$lateral_yards), 0, .data$lateral_yards),
lateral_tds = dplyr::if_else(is.na(.data$lateral_tds), 0L, .data$lateral_tds),
lateral_fumbles = dplyr::if_else(is.na(.data$lateral_fumbles), 0, .data$lateral_fumbles),
lateral_fumbles_lost = dplyr::if_else(is.na(.data$lateral_fumbles_lost), 0, .data$lateral_fumbles_lost),
lateral_fds = dplyr::if_else(is.na(.data$lateral_fds), 0, .data$lateral_fds)
) %>%
dplyr::mutate(
receiving_yards = .data$yards + .data$lateral_yards,
receiving_tds = .data$tds + .data$lateral_tds,
receiving_yards_after_catch = .data$receiving_yards_after_catch + .data$lateral_yards,
receiving_first_downs = .data$receiving_first_downs + .data$lateral_fds,
receiving_fumbles = .data$receiving_fumbles + .data$lateral_fumbles,
receiving_fumbles_lost = .data$receiving_fumbles_lost + .data$lateral_fumbles_lost,
racr = .data$receiving_yards / .data$receiving_air_yards,
racr = dplyr::case_when(
is.nan(.data$racr) ~ NA_real_,
.data$receiving_air_yards == 0 ~ 0,
.data$receiving_air_yards < 0 & !.data$receiver_player_id %in% racr_ids$gsis_id ~ 0,
TRUE ~ .data$racr
),
target_share = .data$targets / .data$team_targets,
air_yards_share = .data$receiving_air_yards / .data$team_air_yards,
wopr = 1.5 * .data$target_share + 0.7 * .data$air_yards_share
) %>%
dplyr::rename(player_id = .data$receiver_player_id) %>%
dplyr::select("player_id", "week", "season", "name_receiver", "team_receiver",
"receiving_yards", "receiving_air_yards", "receiving_yards_after_catch",
"receptions", "targets", "receiving_tds", "receiving_fumbles",
"receiving_fumbles_lost", "receiving_first_downs", "receiving_epa",
"racr", "target_share", "air_yards_share", "wopr")
rec_two_points <- two_points %>%
dplyr::filter(.data$pass_attempt == 1) %>%
dplyr::group_by(.data$receiver_player_id, .data$week, .data$season) %>%
dplyr::summarise(
name_receiver = custom_mode(.data$receiver_player_name),
team_receiver = custom_mode(.data$posteam),
receiving_2pt_conversions = dplyr::n()
) %>%
dplyr::rename(player_id = .data$receiver_player_id) %>%
dplyr::ungroup()
rec_df <- rec_df %>%
dplyr::full_join(rec_two_points, by = c("player_id", "week", "season", "name_receiver", "team_receiver")) %>%
dplyr::mutate(receiving_2pt_conversions = dplyr::if_else(is.na(.data$receiving_2pt_conversions), 0L, .data$receiving_2pt_conversions)) %>%
dplyr::filter(!is.na(.data$player_id))
rec_df_nas <- is.na(rec_df)
epa_index <- which(dimnames(rec_df_nas)[[2]] == c("receiving_epa", "racr", "target_share", "air_yards_share", "wopr"))
rec_df_nas[,epa_index] <- c(FALSE)
rec_df[rec_df_nas] <- 0
st_tds <- pbp %>%
dplyr::filter(.data$special == 1 & !is.na(.data$td_player_id)) %>%
dplyr::group_by(.data$td_player_id, .data$week, .data$season) %>%
dplyr::summarise(
name_st = custom_mode(.data$td_player_name),
team_st = custom_mode(.data$td_team),
special_teams_tds = sum(.data$touchdown, na.rm = TRUE)
) %>%
dplyr::rename(player_id = .data$td_player_id)
player_df <- pass_df %>%
dplyr::full_join(rush_df, by = c("player_id", "week", "season")) %>%
dplyr::full_join(rec_df, by = c("player_id", "week", "season")) %>%
dplyr::full_join(st_tds, by = c("player_id", "week", "season")) %>%
dplyr::left_join(s_type, by = c("season", "week")) %>%
dplyr::mutate(
player_name = dplyr::case_when(
!is.na(.data$name_pass) ~ .data$name_pass,
!is.na(.data$name_rush) ~ .data$name_rush,
!is.na(.data$name_receiver) ~ .data$name_receiver,
TRUE ~ .data$name_st
),
recent_team = dplyr::case_when(
!is.na(.data$team_pass) ~ .data$team_pass,
!is.na(.data$team_rush) ~ .data$team_rush,
!is.na(.data$team_receiver) ~ .data$team_receiver,
TRUE ~ .data$team_st
)
) %>%
dplyr::select(tidyselect::any_of(c(
"player_id", "player_name", "recent_team", "season", "week", "season_type",
"completions", "attempts", "passing_yards", "passing_tds", "interceptions",
"sacks", "sack_yards", "sack_fumbles", "sack_fumbles_lost", "passing_air_yards", "passing_yards_after_catch",
"passing_first_downs", "passing_epa", "passing_2pt_conversions", "pacr", "dakota",
"carries", "rushing_yards", "rushing_tds", "rushing_fumbles", "rushing_fumbles_lost",
"rushing_first_downs", "rushing_epa", "rushing_2pt_conversions",
"receptions", "targets", "receiving_yards", "receiving_tds", "receiving_fumbles",
"receiving_fumbles_lost", "receiving_air_yards", "receiving_yards_after_catch",
"receiving_first_downs", "receiving_epa", "receiving_2pt_conversions", "racr",
"target_share", "air_yards_share", "wopr",
"special_teams_tds"
))) %>%
dplyr::filter(!is.na(.data$player_id))
player_df_nas <- is.na(player_df)
epa_index <- which(dimnames(player_df_nas)[[2]] %in% c("passing_epa", "rushing_epa", "receiving_epa", "dakota", "racr", "target_share", "air_yards_share", "wopr", "pacr"))
player_df_nas[,epa_index] <- c(FALSE)
player_df[player_df_nas] <- 0
player_df <- player_df %>%
dplyr::mutate(
fantasy_points =
1 / 25 * .data$passing_yards +
4 * .data$passing_tds +
-2 * .data$interceptions +
1 / 10 * (.data$rushing_yards + .data$receiving_yards) +
6 * (.data$rushing_tds + .data$receiving_tds + .data$special_teams_tds) +
2 * (.data$passing_2pt_conversions + .data$rushing_2pt_conversions + .data$receiving_2pt_conversions) +
-2 * (.data$sack_fumbles_lost + .data$rushing_fumbles_lost + .data$receiving_fumbles_lost),
fantasy_points_ppr = .data$fantasy_points + .data$receptions
) %>%
dplyr::arrange(.data$player_id, .data$season, .data$week)
if (isFALSE(weekly)) {
player_df <- player_df %>%
dplyr::group_by(.data$player_id) %>%
dplyr::summarise(
player_name = custom_mode(.data$player_name),
games = dplyr::n(),
recent_team = dplyr::last(.data$recent_team),
completions = sum(.data$completions),
attempts = sum(.data$attempts),
passing_yards = sum(.data$passing_yards),
passing_tds = sum(.data$passing_tds),
interceptions = sum(.data$interceptions),
sacks = sum(.data$sacks),
sack_yards = sum(.data$sack_yards),
sack_fumbles = sum(.data$sack_fumbles),
sack_fumbles_lost = sum(.data$sack_fumbles_lost),
passing_air_yards = sum(.data$passing_air_yards),
passing_yards_after_catch = sum(.data$passing_yards_after_catch),
passing_first_downs = sum(.data$passing_first_downs),
passing_epa = dplyr::if_else(all(is.na(.data$passing_epa)), NA_real_, sum(.data$passing_epa, na.rm = TRUE)),
passing_2pt_conversions = sum(.data$passing_2pt_conversions),
pacr = .data$passing_yards / .data$passing_air_yards,
carries = sum(.data$carries),
rushing_yards = sum(.data$rushing_yards),
rushing_tds = sum(.data$rushing_tds),
rushing_fumbles = sum(.data$rushing_fumbles),
rushing_fumbles_lost = sum(.data$rushing_fumbles_lost),
rushing_first_downs = sum(.data$rushing_first_downs),
rushing_epa = dplyr::if_else(all(is.na(.data$rushing_epa)), NA_real_, sum(.data$rushing_epa, na.rm = TRUE)),
rushing_2pt_conversions = sum(.data$rushing_2pt_conversions),
receptions = sum(.data$receptions),
targets = sum(.data$targets),
receiving_yards = sum(.data$receiving_yards),
receiving_tds = sum(.data$receiving_tds),
receiving_fumbles = sum(.data$receiving_fumbles),
receiving_fumbles_lost = sum(.data$receiving_fumbles_lost),
receiving_air_yards = sum(.data$receiving_air_yards),
receiving_yards_after_catch = sum(.data$receiving_yards_after_catch),
receiving_first_downs = sum(.data$receiving_first_downs),
receiving_epa = dplyr::if_else(all(is.na(.data$receiving_epa)), NA_real_, sum(.data$receiving_epa, na.rm = TRUE)),
receiving_2pt_conversions = sum(.data$receiving_2pt_conversions),
racr = .data$receiving_yards / .data$receiving_air_yards,
target_share = dplyr::if_else(all(is.na(.data$target_share)), NA_real_, mean(.data$target_share, na.rm = TRUE)),
air_yards_share = dplyr::if_else(all(is.na(.data$air_yards_share)), NA_real_, mean(.data$air_yards_share, na.rm = TRUE)),
wopr = 1.5 * .data$target_share + 0.7 * .data$air_yards_share,
special_teams_tds = sum(.data$special_teams_tds),
fantasy_points = sum(.data$fantasy_points),
fantasy_points_ppr = sum(.data$fantasy_points_ppr)
) %>%
dplyr::ungroup() %>%
dplyr::mutate(
racr = dplyr::case_when(
is.nan(.data$racr) ~ NA_real_,
.data$receiving_air_yards == 0 ~ 0,
.data$receiving_air_yards < 0 & !.data$player_id %in% racr_ids$gsis_id ~ 0,
TRUE ~ .data$racr
),
pacr = dplyr::case_when(
is.nan(.data$pacr) ~ NA_real_,
.data$passing_air_yards <= 0 ~ 0,
TRUE ~ .data$pacr
)
) %>%
add_dakota(pbp = pbp, weekly = weekly) %>%
dplyr::select(
.data$player_id:.data$pacr,
.data$dakota,
dplyr::everything()
)
}
return(player_df)
}
add_dakota <- function(add_to_this, pbp, weekly) {
dakota_model <- NULL
con <- url("https://github.com/nflverse/nflfastR-data/blob/master/models/dakota_model.Rdata?raw=true")
try(load(con), silent = TRUE)
close(con)
if (is.null(dakota_model)) {
user_message("This function needs to download the model data from GitHub. Please check your Internet connection and try again!", "oops")
return(add_to_this)
}
if (!"id" %in% names(pbp)) pbp <- clean_pbp(pbp)
if (!"qb_epa" %in% names(pbp)) pbp <- add_qb_epa(pbp)
suppressMessages({
df <- pbp %>%
dplyr::filter(.data$pass == 1 | .data$rush == 1) %>%
dplyr::filter(!is.na(.data$posteam) & !is.na(.data$qb_epa) & !is.na(.data$id) & !is.na(.data$down)) %>%
dplyr::mutate(epa = dplyr::if_else(.data$qb_epa < -4.5, -4.5, .data$qb_epa)) %>%
decode_player_ids()
})
if (isTRUE(weekly)) {
relevant_players <- add_to_this %>%
dplyr::filter(.data$attempts >= 5) %>%
dplyr::mutate(filter_id = paste(.data$player_id, .data$season, .data$week, sep = "_")) %>%
dplyr::pull(.data$filter_id)
model_data <- df %>%
dplyr::group_by(.data$id, .data$week, .data$season) %>%
dplyr::summarize(
n_plays = n(),
epa_per_play = sum(.data$epa) / .data$n_plays,
cpoe = mean(.data$cpoe, na.rm = TRUE)
) %>%
dplyr::ungroup() %>%
dplyr::mutate(cpoe = dplyr::if_else(is.na(.data$cpoe), 0, .data$cpoe)) %>%
dplyr::rename(player_id = .data$id) %>%
dplyr::mutate(filter_id = paste(.data$player_id, .data$season, .data$week, sep = "_")) %>%
dplyr::filter(.data$filter_id %in% relevant_players)
model_data$dakota <- mgcv::predict.gam(dakota_model, model_data) %>% as.vector()
out <- add_to_this %>%
dplyr::left_join(
model_data %>%
dplyr::select(.data$player_id, .data$week, .data$season, .data$dakota),
by = c("player_id", "week", "season")
)
} else if (isFALSE(weekly)) {
relevant_players <- add_to_this %>%
dplyr::filter(.data$attempts >= 5) %>%
dplyr::pull(.data$player_id)
model_data <- df %>%
dplyr::group_by(.data$id) %>%
dplyr::summarize(
n_plays = n(),
epa_per_play = sum(.data$epa) / .data$n_plays,
cpoe = mean(.data$cpoe, na.rm = TRUE)
) %>%
dplyr::ungroup() %>%
dplyr::mutate(cpoe = dplyr::if_else(is.na(.data$cpoe), 0, .data$cpoe)) %>%
dplyr::rename(player_id = .data$id) %>%
dplyr::filter(.data$player_id %in% relevant_players)
model_data$dakota <- mgcv::predict.gam(dakota_model, model_data) %>% as.vector()
out <- add_to_this %>%
dplyr::left_join(
model_data %>%
dplyr::select(.data$player_id, .data$dakota),
by = "player_id"
)
}
return(out)
}
|
theme_ipsum_ps <- function(
base_family="IBMPlexSans", base_size = 11.5,
plot_title_family="IBMPlexSans-Bold", plot_title_size = 18,
plot_title_face="plain", plot_title_margin = 10,
subtitle_family=if (.Platform$OS.type == "windows") "IBMPlexSans" else "IBMPlexSans-Light",
subtitle_size = 13,
subtitle_face = "plain", subtitle_margin = 15,
strip_text_family = "IBMPlexSans-Medium", strip_text_size = 12,
strip_text_face = "plain",
caption_family=if (.Platform$OS.type == "windows") "IBMPlexSans" else "IBMPlexSans-Thin",
caption_size = 9,
caption_face = "plain", caption_margin = 10,
axis_text_size = 9,
axis_title_family = base_family,
axis_title_size = 9,
axis_title_face = "plain",
axis_title_just = "rt",
plot_margin = margin(30, 30, 30, 30),
grid_col = "
axis_col = "
ret <- ggplot2::theme_minimal(base_family=base_family, base_size=base_size)
ret <- ret + theme(legend.background=element_blank())
ret <- ret + theme(legend.key=element_blank())
if (inherits(grid, "character") | grid == TRUE) {
ret <- ret + theme(panel.grid=element_line(color=grid_col, size=0.2))
ret <- ret + theme(panel.grid.major=element_line(color=grid_col, size=0.2))
ret <- ret + theme(panel.grid.minor=element_line(color=grid_col, size=0.15))
if (inherits(grid, "character")) {
if (regexpr("X", grid)[1] < 0) ret <- ret + theme(panel.grid.major.x=element_blank())
if (regexpr("Y", grid)[1] < 0) ret <- ret + theme(panel.grid.major.y=element_blank())
if (regexpr("x", grid)[1] < 0) ret <- ret + theme(panel.grid.minor.x=element_blank())
if (regexpr("y", grid)[1] < 0) ret <- ret + theme(panel.grid.minor.y=element_blank())
}
} else {
ret <- ret + theme(panel.grid=element_blank())
}
if (inherits(axis, "character") | axis == TRUE) {
ret <- ret + theme(axis.line=element_line(color=axis_col, size=0.15))
if (inherits(axis, "character")) {
axis <- tolower(axis)
if (regexpr("x", axis)[1] < 0) {
ret <- ret + theme(axis.line.x=element_blank())
} else {
ret <- ret + theme(axis.line.x=element_line(color=axis_col, size=0.15))
}
if (regexpr("y", axis)[1] < 0) {
ret <- ret + theme(axis.line.y=element_blank())
} else {
ret <- ret + theme(axis.line.y=element_line(color=axis_col, size=0.15))
}
} else {
ret <- ret + theme(axis.line.x=element_line(color=axis_col, size=0.15))
ret <- ret + theme(axis.line.y=element_line(color=axis_col, size=0.15))
}
} else {
ret <- ret + theme(axis.line=element_blank())
}
if (!ticks) {
ret <- ret + theme(axis.ticks = element_blank())
ret <- ret + theme(axis.ticks.x = element_blank())
ret <- ret + theme(axis.ticks.y = element_blank())
} else {
ret <- ret + theme(axis.ticks = element_line(size=0.15))
ret <- ret + theme(axis.ticks.x = element_line(size=0.15))
ret <- ret + theme(axis.ticks.y = element_line(size=0.15))
ret <- ret + theme(axis.ticks.length = grid::unit(5, "pt"))
}
xj <- switch(tolower(substr(axis_title_just, 1, 1)), b=0, l=0, m=0.5, c=0.5, r=1, t=1)
yj <- switch(tolower(substr(axis_title_just, 2, 2)), b=0, l=0, m=0.5, c=0.5, r=1, t=1)
ret <- ret + theme(axis.text.x=element_text(size=axis_text_size, margin=margin(t=0)))
ret <- ret + theme(axis.text.y=element_text(size=axis_text_size, margin=margin(r=0)))
ret <- ret + theme(axis.title=element_text(size=axis_title_size, family=axis_title_family))
ret <- ret + theme(axis.title.x=element_text(hjust=xj, size=axis_title_size,
family=axis_title_family, face=axis_title_face))
ret <- ret + theme(axis.title.y=element_text(hjust=yj, size=axis_title_size,
family=axis_title_family, face=axis_title_face))
ret <- ret + theme(axis.title.y.right=element_text(hjust=yj, size=axis_title_size, angle=90,
family=axis_title_family, face=axis_title_face))
ret <- ret + theme(strip.text=element_text(hjust=0, size=strip_text_size,
face=strip_text_face, family=strip_text_family))
ret <- ret + theme(panel.spacing=grid::unit(2, "lines"))
ret <- ret + theme(plot.title=element_text(hjust=0, size=plot_title_size,
margin=margin(b=plot_title_margin),
family=plot_title_family, face=plot_title_face))
ret <- ret + theme(plot.subtitle=element_text(hjust=0, size=subtitle_size,
margin=margin(b=subtitle_margin),
family=subtitle_family, face=subtitle_face))
ret <- ret + theme(plot.caption=element_text(hjust=1, size=caption_size,
margin=margin(t=caption_margin),
family=caption_family, face=caption_face))
ret <- ret + theme(plot.margin=plot_margin)
ret
}
import_plex_sans <- function() {
ps_font_dir <- system.file("fonts", "plex-sans", package="hrbrthemes")
}
font_ps <- "IBMPlexSans"
font_ps_light <- "IBMPlexSans-Light"
|
VPA <- function(x = 1, Data, AddInd = "B", expanded = FALSE, SR = c("BH", "Ricker"), vulnerability = c("logistic", "dome", "free"),
start = list(), fix_h = TRUE, fix_Fratio = TRUE, fix_Fterm = FALSE, LWT = NULL, shrinkage = list(), n_itF = 5L,
min_age = "auto", max_age = "auto", refpt = list(),
silent = TRUE, opt_hess = FALSE, n_restart = ifelse(opt_hess, 0, 1),
control = list(iter.max = 2e5, eval.max = 4e5), ...) {
dependencies <- "Data@Cat, Data@CAA, Data@Ind, Data@Mort, Data@L50, Data@L95, Data@CAA, Data@vbK, Data@vbLinf, Data@vbt0, Data@wla, Data@wlb, Data@MaxAge"
dots <- list(...)
if(!is.null(dots$nitF)) n_itF <- dots$nitF
start <- lapply(start, eval, envir = environment())
vulnerability <- match.arg(vulnerability)
SR <- match.arg(SR)
if(is.null(refpt$weight)) refpt$weight <- 3L
if(is.null(refpt$vul)) refpt$vul <- 3L
if(is.null(refpt$R)) refpt$R <- c(0.5, 5)
n_age <- Data@MaxAge + 1
M <- rep(Data@Mort[x], n_age)
a <- Data@wla[x]
b <- Data@wlb[x]
Linf <- Data@vbLinf[x]
K <- Data@vbK[x]
t0 <- Data@vbt0[x]
La <- Linf * (1 - exp(-K * (c(0:Data@MaxAge) - t0)))
Wa <- a * La ^ b
A50 <- min(0.5 * Data@MaxAge, iVB(t0, K, Linf, Data@L50[x]))
A95 <- max(A50+0.5, iVB(t0, K, Linf, Data@L95[x]))
mat_age <- 1/(1 + exp(-log(19) * (c(0:Data@MaxAge) - A50)/(A95 - A50)))
mat_age <- mat_age/max(mat_age)
if(any(names(dots) == "yind")) {
yind <- eval(dots$yind)
} else {
yind <- 1:nrow(Data@CAA[x, , ])
}
Year <- Data@Year[yind]
CAA_hist <- Data@CAA[x, yind, ]
if(!expanded) {
C_hist <- Data@Cat[x, yind]
if(any(is.na(C_hist) | C_hist < 0)) warning("Error. Catch time series is not complete.")
expansion_factors <- C_hist/colSums(t(CAA_hist) * Wa)
CAA_hist <- CAA_hist * expansion_factors
}
CAA_hist_VPA <- CAA_hist
if(is.character(max_age) && max_age == "auto") {
max_age <- n_age - 1
while(any(CAA_hist_VPA[, max_age + 1] <= 0)) {
max_age <- max_age - 1
CAA_hist_VPA <- CAA_hist[, 0:max_age + 1]
CAA_hist_VPA[, max_age + 1] <- rowSums(CAA_hist[, (max_age+1):ncol(CAA_hist), drop = FALSE])
}
} else if(is.numeric(max_age) && length(max_age) == 1) {
CAA_hist_VPA <- CAA_hist[, 0:max_age + 1]
CAA_hist_VPA[, max_age + 1] <- rowSums(CAA_hist[, (max_age+1):ncol(CAA_hist), drop = FALSE])
} else {
stop("max_age must be an integer or \"auto\".")
}
if(is.character(min_age) && min_age == "auto") {
min_age <- 0
while(CAA_hist[nrow(CAA_hist), min_age + 1] <= 0) min_age <- min_age + 1
}
if(is.numeric(min_age) && length(min_age) == 1) {
if(min_age > 0) {
CAA_hist_VPA <- CAA_hist_VPA[, -c(0:min_age + 1), drop = FALSE]
CAA_hist_VPA <- CAA_hist[, 0:min_age + 1, drop = FALSE] %>% rowSums() %>% cbind(CAA_hist_VPA)
if(ncol(CAA_hist_VPA) == 1) stop("Only one age class left after consolidating plus- and minus- groups to remove zeros.")
}
} else {
stop("min_age must be an integer or \"auto\".")
}
ages <- min_age:max_age
CAA_hist_VPA[is.na(CAA_hist_VPA) | CAA_hist_VPA < 1e-8] <- 1e-8
maxage_ind <- CAA_hist_VPA[, ncol(CAA_hist_VPA) - 1] == 1e-8
CAA_hist_VPA[maxage_ind, ncol(CAA_hist_VPA) - 1] <- CAA_hist_VPA[maxage_ind, ncol(CAA_hist_VPA)]
update_age_schedule <- function(x, ages) {
xout <- x[ages + 1]
xout[length(xout)] <- mean(x[(max(ages)+1):length(x)])
return(xout %>% structure(names = ages))
}
LH <- list(LAA = update_age_schedule(La, ages), WAA = update_age_schedule(Wa, ages),
Linf = Linf, K = K, t0 = t0, a = a, b = b, A50 = A50, A95 = A95,
mat = update_age_schedule(mat_age, ages))
Ind <- lapply(AddInd, Assess_I_hist, Data = Data, x = x, yind = yind)
I_hist <- do.call(cbind, lapply(Ind, getElement, "I_hist"))
I_sd <- do.call(cbind, lapply(Ind, getElement, "I_sd")) %>% pmax(0.05)
I_units <- do.call(c, lapply(Ind, getElement, "I_units"))
I_vul <- vapply(AddInd, function(xx) {
if(xx == "B") {
return(rep(1, length(ages)))
} else if(xx == "SSB") {
return(LH$mat)
} else if(xx == "VB") {
return(rep(0, length(ages)))
} else {
return(Data@AddIndV[x, suppressWarnings(as.numeric(xx)), ages + 1])
}
}, numeric(length(ages)))
nsurvey <- ncol(I_hist)
if(is.null(LWT)) LWT <- rep(1, nsurvey)
if(length(LWT) != nsurvey) stop("LWT needs to be a vector of length ", nsurvey)
if(is.null(shrinkage$vul)) shrinkage$vul <- c(3, 0.4)
if(is.null(shrinkage$R)) {
sigmaR <- Data@sigmaR[x]
if(is.null(sigmaR)) sigmaR <- 0.6
shrinkage$R <- c(3, sigmaR)
}
data <- list(model = "VPA", I_hist = I_hist, I_sd = I_sd, I_units = I_units, I_vul = I_vul,
abs_I = rep(0, nsurvey), nsurvey = nsurvey, LWT = LWT,
CAA_hist = CAA_hist_VPA, n_y = length(Year), n_age = length(ages),
M = update_age_schedule(M, ages), weight = LH$WAA,
vul_type_term = vulnerability, n_itF = as.integer(n_itF),
n_vulpen = shrinkage$vul[1], vulpen = shrinkage$vul[2],
n_Rpen = shrinkage$R[1], Rpen = shrinkage$R[2])
params <- list()
if(!is.null(start)) {
if(!is.null(start$Fterm) && is.numeric(start$Fterm)) params$log_Fterm <- log(start$Fterm)
if(!is.null(start$Fratio) && is.numeric(start$Fratio)) params$log_Fratio <- log(start$Fratio)
if(!is.null(start$vul_par) && is.numeric(start$vul_par)) {
if(vulnerability == "logistic") {
if(start$vul_par[1] > 0.75 * max_age) stop("start$vul_par[1] needs to be less than 0.75 * max_age (", max_age, ")")
if(length(start$vul_par) < 2) stop("Two parameters needed for start$vul_par with logistic vulnerability (see help).")
if(start$vul_par[1] <= start$vul_par[2]) stop("start$vul_par[1] needs to be greater than start$vul_par[2] (see help).")
params$vul_par <- c(logit(start$vul_par[1]/max_age/0.75), log(start$vul_par[1] - start$vul_par[2]))
} else if(vulnerability == "dome") {
if(start$vul_par[1] > 0.75 * max_age) stop("start$vul_par[1] needs to be less than 0.75 * max_age (", max_age, ")")
if(length(start$vul_par) < 4) stop("Four parameters needed for start$vul_par with dome vulnerability (see help).")
if(start$vul_par[1] <= start$vul_par[2]) stop("start$vul_par[1] needs to be greater than start$vul_par[2] (see help).")
if(start$vul_par[3] <= start$vul_par[1] || start$vul_par[3] >= max_age) {
stop("start$vul_par[3] needs to be between start$vul_par[1] and max_age (", max_age, ")")
}
if(start$vul_par[4] <= 0 || start$vul_par[4] >= 1) stop("start$vul_par[4] needs to be between 0-1 (see help).")
params$vul_par <- c(logit(start$vul_par[1]/max_age/0.75), log(start$vul_par[1] - start$vul_par[2]),
logit(1/(max_age - start$vul_par[1])), logit(start$vul_par[4]))
} else if(vulnerability == "free") {
if(length(start$vul_par) < length(ages)) stop(paste0("start$vul_par needs to be of length", length(ages), "."))
params$vul_par <- log(start$vul_par[1:length(ages)])
}
}
}
if(is.null(params$log_Fterm)) params$log_Fterm <- log(0.2)
if(is.null(params$log_Fratio)) params$log_Fratio <- log(1)
if(is.null(params$vul_par)) {
CAA_mode <- ages[which.max(colSums(CAA_hist, na.rm = TRUE))]
CAA_mode <- ifelse(CAA_mode + 1 > max_age, max_age - 1, CAA_mode)
if(vulnerability == "free") {
params$vul_par <- ifelse(ages[-length(ages)] < CAA_mode, 0.5, 1) %>% log()
} else {
if((is.na(Data@LFC[x]) && is.na(Data@LFS[x])) || (Data@LFC[x] > Linf) || (Data@LFS[x] > Linf)) {
if(vulnerability == "logistic") params$vul_par <- c(logit(CAA_mode/(max_age - min_age)/0.75), log(1))
if(vulnerability == "dome") {
params$vul_par <- c(logit(CAA_mode/(max_age - min_age)/0.75), log(1), logit(1/(max_age - CAA_mode)), logit(0.5))
}
} else {
A5 <- min(iVB(t0, K, Linf, Data@LFC[x]), CAA_mode-1)
Afull <- min(iVB(t0, K, Linf, Data@LFS[x]), 0.5 * max_age)
A5 <- min(A5, Afull - 0.5)
A50_vul <- mean(c(A5, Afull))
if(vulnerability == "logistic") params$vul_par <- c(logit(Afull/(max_age - min_age)/0.75), log(Afull - A50_vul))
if(vulnerability == "dome") {
params$vul_par <- c(logit(Afull/max_age/0.75), log(Afull - A50_vul), logit(1/(max_age - Afull)), logit(0.5))
}
}
}
}
info <- list(Year = Year, data = data, params = params, LH = LH, SR = SR, ages = ages, control = control,
fix_h = fix_h, refpt = refpt)
map <- list()
if(vulnerability == "free") {
fixed_ind <- round(0.5 * length(ages))
free_vul_par <- rep(log(1), length(ages) - 1)
free_vul_par[fixed_ind] <- NA
free_vul_par[!is.na(free_vul_par)] <- 1:(length(ages)-2)
map$vul_par <- factor(free_vul_par)
} else if(vulnerability == "dome") {
map$vul_par <- c(1, 2, NA, 3) %>% factor()
}
if(fix_Fratio) map$log_Fratio <- factor(NA)
if(fix_Fterm) map$log_Fterm <- factor(NA)
obj <- MakeADFun(data = info$data, parameters = info$params, hessian = TRUE,
map = map, DLL = "SAMtool", silent = silent)
mod <- optimize_TMB_model(obj, control, opt_hess, n_restart)
opt <- mod[[1]]
SD <- mod[[2]]
report <- obj$report(obj$env$last.par.best) %>% VPA_posthoc(info = info)
Yearplusone <- c(Year, max(Year) + 1)
Assessment <- new("Assessment", Model = "VPA",
Name = Data@Name, conv = SD$pdHess,
FMort = structure(report$F, names = Year),
B = structure(report$B, names = Yearplusone), SSB = structure(report$E, names = Yearplusone),
VB = structure(report$VB, names = Yearplusone),
R = structure(report$N[, 1], names = Yearplusone), N = structure(rowSums(report$N), names = Yearplusone),
N_at_age = report$N, Selectivity = report$vul, h = NA_real_,
Obs_Catch = structure(if(expanded) colSums(t(CAA_hist_VPA) * data$weight) else C_hist, names = Year),
Obs_Index = structure(I_hist, dimnames = list(Year, paste0("Index_", 1:nsurvey))),
Obs_C_at_age = CAA_hist_VPA,
Catch = structure(colSums(t(report$CAApred) * data$weight), names = Year),
Index = structure(report$Ipred, dimnames = list(Year, paste0("Index_", 1:nsurvey))),
C_at_age = report$CAApred,
NLL = structure(c(report$nll, report$nll_comp, report$prior, report$penalty),
names = c("Total", paste0("Index_", 1:nsurvey), "Prior", "Penalty")),
info = info, obj = obj, opt = opt, SD = SD, TMB_report = report,
dependencies = dependencies)
if(Assessment@conv) {
ref_pt <- ref_pt_VPA(E = report$E[1:(length(report$E)-min_age)], R = report$N[(min_age + 1):length(report$E), 1],
weight = info$data$weight, mat = info$LH$mat, M = info$data$M, vul = report$vul_p,
SR = SR, fix_h = fix_h, h = ifelse(fix_h, Data@steep[x], NA_real_))
report <- c(report, ref_pt[-17])
Assessment@FMSY <- report$FMSY
Assessment@MSY <- report$MSY
Assessment@BMSY <- report$BMSY
Assessment@SSBMSY <- report$EMSY
Assessment@VBMSY <- report$VBMSY
Assessment@B0 <- report$B0
Assessment@R0 <- report$R0
Assessment@N0 <- report$N0
Assessment@SSB0 <- report$E0
Assessment@VB0 <- report$VB0
Assessment@h <- report$h
Assessment@F_FMSY <- Assessment@FMort/report$FMSY
Assessment@B_BMSY <- structure(report$B/report$BMSY, names = Yearplusone)
Assessment@B_B0 <- structure(report$B/report$B0, names = Yearplusone)
Assessment@SSB_SSBMSY <- structure(report$E/report$EMSY, names = Yearplusone)
Assessment@SSB_SSB0 <- structure(report$E/report$E0, names = Yearplusone)
Assessment@VB_VBMSY <- structure(report$VB/report$VBMSY, names = Yearplusone)
Assessment@VB_VB0 <- structure(report$VB/report$VB0, names = Yearplusone)
Assessment@TMB_report <- report
catch_eq <- function(Ftarget) {
catch_equation(method = "Baranov", sel = report$vul_p, M = info$data$M,
wt = info$data$weight, N = report@N[nrow(report$N), ])
}
Assessment@forecast <- list(per_recruit = ref_pt[[17]], catch_eq = catch_eq)
}
return(Assessment)
}
VPA_posthoc <- function(report, info) {
n_age <- info$data$n_age
Y <- nrow(report$N)
N <- numeric(n_age)
M <- info$data$M
FF <- report$F_at_age[Y, ]
Z <- M + FF
refpt <- info$refpt
N[2:n_age] <- report$N[Y, 1:(n_age-1)] * exp(-Z[1:(n_age-1)])
N[n_age] <- N[n_age] + report$N[Y, n_age] * exp(-Z[n_age])
N[1] <- quantile(report$N[(Y-refpt$R[2]+1):Y, 1], refpt$R[1])
report$vul_p <- report$vul[(Y-refpt$vul+1):Y, , drop = FALSE] %>% apply(2, mean)
report$vul_p <- report$vul_p/max(report$vul_p)
report$N <- rbind(report$N, N)
report$E <- colSums(t(report$N) * info$LH$mat * info$data$weight)
report$VB <- c(report$VB, sum(N * report$vul_p * info$data$weight))
report$B <- c(report$B, sum(N * info$data$weight))
return(report)
}
ref_pt_VPA <- function(E, R, weight, mat, M, vul, SR, fix_h, h) {
NPR0 <- calc_NPR(exp(-M), length(M))
EPR0 <- sum(NPR0 * weight * mat)
Rpred <- sigmaR <- NULL
solve_SR_par <- function(x, h = NULL) {
R0 <- exp(x[1])
E0 <- R0 * EPR0
if(!fix_h) {
if(SR == "BH") h <- 0.2 + 0.8 * ilogit(x[2])
if(SR == "Ricker") h <- 0.2 + exp(x[2])
}
if(SR == "BH") Rpred <<- (0.8 * R0 * h * E)/(0.2 * EPR0 * R0 *(1-h)+(h-0.2)*E)
if(SR == "Ricker") Rpred <<- E/EPR0 * (5*h)^(1.25 * (1 - E/E0))
sigmaR <<- sqrt(sum((log(R/Rpred))^2)/length(Rpred))
nLL <- -sum(dnorm(log(R/Rpred), -0.5 * sigmaR^2, sigmaR, log = TRUE))
return(nLL)
}
if(fix_h) {
opt <- optimize(solve_SR_par, interval = c(-10, 10), h = h)$minimum
R0 <- exp(opt)
} else {
opt <- nlminb(c(10, 10), solve_SR_par)
R0 <- exp(opt$par[1])
if(SR == "BH") h <- 0.2 + 0.8 * ilogit(opt$par[2])
if(SR == "Ricker") h <- 0.2 + exp(opt$par[2])
}
N0 <- R0 * sum(NPR0)
E0 <- R0 * EPR0
VB0 <- R0 * sum(NPR0 * weight * vul)
B0 <- R0 * sum(NPR0 * weight)
if(SR == "BH") {
Arec <- 4*h/(1-h)/EPR0
Brec <- (5*h-1)/(1-h)/E0
}
if(SR == "Ricker") {
Arec <- 1/EPR0 * (5*h)^1.25
Brec <- 1.25 * log(5*h) / E0
}
opt2 <- optimize(yield_fn_SCA, interval = c(1e-4, 4), M = M, mat = mat, weight = weight, vul = vul,
SR = SR, Arec = Arec, Brec = Brec)
opt3 <- yield_fn_SCA(opt2$minimum, M = M, mat = mat, weight = weight, vul = vul, SR = SR,
Arec = Arec, Brec = Brec, opt = FALSE)
FMSY <- opt2$minimum
MSY <- -1 * opt2$objective
VBMSY <- opt3["VB"]
RMSY <- opt3["R"]
BMSY <- opt3["B"]
EMSY <- opt3["E"]
Fvec <- seq(0, 2.5 * FMSY, length.out = 100)
yield <- lapply(Fvec,
yield_fn_SCA, M = M, mat = mat, weight = weight, vul = vul, SR = SR,
Arec = Arec, Brec = Brec, opt = FALSE)
SPR <- vapply(yield, getElement, numeric(1), "EPR")
YPR <- vapply(yield, getElement, numeric(1), "YPR")
refpt_unfished <- list(h = h, Arec = Arec, Brec = Brec, E0 = E0, R0 = R0, N0 = N0, VB0 = VB0, B0 = B0, EPR0 = EPR0, NPR0 = NPR0)
refpt_MSY <- list(FMSY = FMSY, MSY = MSY, VBMSY = VBMSY, RMSY = RMSY, BMSY = BMSY, EMSY = EMSY,
per_recruit = data.frame(FM = Fvec, SPR = SPR/SPR[1], YPR = YPR))
return(c(refpt_unfished, refpt_MSY))
}
|
minConnectivityID <- function(g, deg=NULL) {
if (class(g)[1] != "graphNEL")
stop("'g' has to be a 'graphNEL' object")
stopifnot(.validateGraph(g))
if (is.null(deg))
deg <- graph::degree(g)
.weightedMinPathSum(g, weightfunc=function(i, from, to) (1 / sqrt(deg[[from]] * deg[[to]])))
}
|
Bream_pop_pre<-function(userpath,forcings){
rm(list=ls())
cat("Data preprocessing")
timeT=forcings[[1]]
Tint=forcings[[2]]
timeG=forcings[[3]]
Gint=forcings[[4]]
Param_matrix=read.csv(paste0(userpath,"/Bream_population/Inputs/Parameters//Parameters.csv"),sep=",")
Food=read.csv(paste0(userpath,"/Bream_population/Inputs/Forcings//Food_characterization.csv"),sep=",",header=FALSE)
Param=as.matrix(Param_matrix[1:21,3])
Param=suppressWarnings(as.numeric(Param))
Dates=Param_matrix[22:23,3]
CS=as.double(as.matrix(Param_matrix[25,3]))
Food=as.double(as.matrix(Food[,1]))
t0=min(as.numeric(as.Date(timeT[1], "%d/%m/%Y")), as.numeric(as.Date(timeG[1], "%d/%m/%Y")), as.numeric(as.Date(Dates[1], "%d/%m/%Y")))
timestep=1
ti=as.numeric(as.Date(Dates[1], "%d/%m/%Y"))-t0
tf=as.numeric(as.Date(Dates[2], "%d/%m/%Y"))-t0
times<-cbind(ti, tf, timestep,t0)
Pcont=Food[1]
Lcont=Food[2]
Ccont=Food[3]
Pop_matrix=read.csv(paste0(userpath,"/Bream_population/Inputs/Parameters//Population.csv"),sep=",")
Management=read.csv(paste0(userpath,"/Bream_population/Inputs/Population_management//Management.csv"),sep=",")
meanW=as.double(as.matrix(Pop_matrix[1,3]))
deltaW=as.double(as.matrix(Pop_matrix[2,3]))
IC=deltaW
Wlb=as.double(as.matrix(Pop_matrix[3,3]))
meanImax=as.double(as.matrix(Pop_matrix[4,3]))
deltaImax=as.double(as.matrix(Pop_matrix[5,3]))
Nseed=as.double(as.matrix(Pop_matrix[6,3]))
mortmyt=as.double(as.matrix(Pop_matrix[7,3]))
nruns=as.double(as.matrix(Pop_matrix[8,3]))
manag=as.matrix(matrix(0,nrow=length(Management[,1]),ncol=2))
for (i in 1:length(Management[,1])) {
manag[i,1]=as.numeric(as.Date(Management[i,1], "%d/%m/%Y"))-t0
if ((Management[i,2])=="h") {
manag[i,2]=-as.numeric(Management[i,3])
} else {
manag[i,2]=as.numeric(Management[i,3])
}
}
N<-Pop_fun(Nseed, mortmyt, manag, times)
cat(" \n")
cat('The model will be executed with the following parameters:\n');
cat(" \n")
for (i in 1:21){
cat(paste0(toString(Param_matrix[i,2]), ": ", toString(Param_matrix[i,3]), " " ,toString(Param_matrix[i,4])),"\n")
}
cat(" \n")
cat("Integration is performed between ", toString(Dates[1]), " and ", toString(Dates[2]),"\n")
cat(" \n")
cat("The food has the following composition: \n")
cat(toString(Pcont*100),"% proteins\n")
cat(toString(Lcont*100),"% lipids\n")
cat(toString(Ccont*100),"% carbohydrates\n")
cat(" \n")
cat('Commercial size is ', toString(CS)," g")
cat(" \n")
cat(" \n")
cat('The population is simulated by assuming that initial weight and maximum ingestion rate are normally distributed:\n');
cat(" \n")
for (i in 1:5){
cat(paste0(toString(Pop_matrix[i,2]), ": ", toString(Pop_matrix[i,3]), " " ,toString(Pop_matrix[i,4])),"\n")
}
cat(" \n")
cat("The population is initially composed by ", toString(Pop_matrix[6,3]), " Individuals\n")
cat(" \n")
cat("The mortality rate is:", toString(Pop_matrix[7,3]),'1/d\n' )
cat(" \n")
cat('The population is managed according with following list (h:harvesting s:seeding):\n');
cat(" \n")
for (i in 1:length(Management[,1])){
cat(paste0(toString(Management[i,1])," ", toString(Management[i,2]), " " ,toString(Management[i,3])),"individuals\n")
}
cat(" \n")
cat("The individual model will be executed ", toString(nruns), " times in order to simulate a population\n")
cat(" \n")
cat(" \n")
cat("Forcings are represented in graphs available at the following folder:\n")
cat(paste0(userpath,"/Bream_population/Inputs/In_plots\n"))
Tintsave=Tint[(ti+1):tf]
currentpath=getwd()
filepath=paste0(userpath,"/Bream_population/Inputs/Forcings_plots//Water_temperature.jpeg")
jpeg(filepath,800,600)
days <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), by = "days", length = tf-ti)
plot(days, Tintsave, ylab="Water temperature (Celsius degrees)", xlab="",xaxt = "n",type="l",cex.lab=1.4)
labDates <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), tail(days, 1), by = "months")
axis.Date(side = 1, days, at = labDates, format = "%d %b %y", las = 2)
dev.off()
Gintsave=Gint[(ti+1):tf]
currentpath=getwd()
filepath=paste0(userpath,"/Bream_population/Inputs/Forcings_plots//Feeding.jpeg")
jpeg(filepath,800,600)
days <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), by = "days", length = tf-ti)
plot(days, Gintsave, ylab="Feed (g/d)", xlab="", xaxt = "n",type="l",cex.lab=1.4)
labDates <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), tail(days, 1), by = "months")
axis.Date(side = 1, days, at = labDates, format = "%d %b %y", las = 2)
dev.off()
Nsave=N[(ti+1):tf]
currentpath=getwd()
filepath=paste0(userpath,"/Bream_population/Inputs/Forcings_plots//Population.jpeg")
jpeg(filepath,800,600)
days <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), by = "days", length = tf-ti)
plot(days, Nsave, ylab="Individuals", xlab="", xaxt = "n",type="l",cex.lab=1.4)
labDates <- seq(as.Date(Dates[1], format = "%d/%m/%Y"), tail(days, 1), by = "months")
axis.Date(side = 1, days, at = labDates, format = "%d %b %y", las = 2)
dev.off()
output=list(Param, Tint, Gint, Food, IC, times, Dates, N,CS)
return(output)
}
|
image_line_segment_detector <- function(x, scale = 0.8,
sigma_scale = 0.6, quant = 2.0, ang_th = 22.5, log_eps = 0.0,
density_th = 0.7, n_bins = 1024,
union = FALSE, union_min_length = 5, union_max_distance = 5,
union_ang_th=7, union_use_NFA=FALSE, union_log_eps = 0.0) {
stopifnot(is.matrix(x))
linesegments <- detect_line_segments(as.numeric(x),
X=nrow(x),
Y=ncol(x),
scale = as.numeric(scale),
sigma_scale = as.numeric(sigma_scale),
quant = as.numeric(quant),
ang_th = as.numeric(ang_th),
log_eps = as.numeric(log_eps),
need_to_union = as.logical(union),
union_use_NFA = as.logical(union_use_NFA),
union_ang_th = as.numeric(union_ang_th),
union_log_eps = as.numeric(union_log_eps),
length_threshold = as.numeric(union_min_length),
dist_threshold = as.numeric(union_max_distance))
names(linesegments) <- c("lines", "pixels")
colnames(linesegments$lines) <- c("x1", "y1", "x2", "y2", "width", "p", "-log_nfa")
linesegments$n <- nrow(linesegments$lines)
class(linesegments) <- "lsd"
linesegments
}
print.lsd <- function(x, ...){
cat("Line Segment Detector", sep = "\n")
cat(sprintf(" found %s line segments", x$n), sep = "\n")
}
plot.lsd <- function(x, ...){
requireNamespace("sp")
out <- sp::SpatialLines(lapply(seq_len(x$n), FUN=function(i){
l <- rbind(
x$lines[i, c("x1", "y1")],
x$lines[i, c("x2", "y2")])
sp::Lines(sp::Line(l), ID = i)
}))
sp::plot(out, ...)
invisible(out)
}
|
read.vgc <- function (file)
{
tmp <- read.delim(auto.gzfile(file))
vars <- colnames(tmp)
if (!("N" %in% vars)) stop("required column 'N' missing from .vgc file ", file)
if (!("V" %in% vars)) stop("required column 'V' missing from .vgc file ", file)
m <- 1:9
idx <- sapply(m, function (x) if (paste("V", x, sep="") %in% vars) TRUE else FALSE)
m.max <- sum(idx)
if (m.max > 0) {
if (any(m[!idx] <= m.max))
stop("spectrum elements must form uninterrupted sequence 'V1', 'V2', ...")
}
variances <- ("VV" %in% vars)
idx.v <- sapply(m, function (x) if (paste("VV", x, sep="") %in% vars) TRUE else FALSE)
m.max.v <- sum(idx.v)
if (m.max.v > 0) {
if (any(m[!idx.v] <= m.max.v))
stop("spectrum variances must form uninterrupted sequence 'VV1', 'VV2', ...")
}
if (!variances && m.max.v > 0)
stop("column 'VV' must also be given if there are variances 'VV1', etc.")
if (variances && (m.max.v != m.max))
stop("variances 'VVm' must be given for exactly the same frequency classes as expectations 'Vm'")
Vm.list <- if (m.max > 0) tmp[ paste("V", 1:m.max, sep="") ] else NULL
if (variances) {
VVm.list <- if (m.max > 0) tmp[ paste("VV", 1:m.max, sep="") ] else NULL
vgc(N=tmp$N, V=tmp$V, VV=tmp$VV, Vm=Vm.list, VVm=VVm.list)
}
else {
vgc(N=tmp$N, V=tmp$V, Vm=Vm.list)
}
}
|
knitr::opts_chunk$set(collapse = TRUE, comment = "
library(alphabetr)
strcsv <-'"chain","well","cdr3"\n"alpha","1","CAVTGGDKLIF"\n"alpha","1","CALDGDKIIF"\n"alpha","2","CAVTGGDKLIF"\n"beta","1","CASGLARAEQYF"\n"beta","2","CASSEGDKVIF"\n"beta","2","CSEVHTARTQYF"'
con <- textConnection(strcsv)
csv3 <- read.csv(con)
head(csv3)
strcsv <-'"well","cdr3"\n"1","CAVTGGDKLIF"\n"1","CALDGDKIIF"\n"2","CAVTGGDKLIF"'
con_alpha <- textConnection(strcsv)
csv2_alpha <- read.csv(con_alpha)
strcsv <-'"well","cdr3"\n"1","CASGLARAEQYF"\n"2","CASSEGDKVIF"\n"2","CSEVHTARTQYF"'
con_beta <- textConnection(strcsv)
csv2_beta <- read.csv(con_beta)
head(csv2_alpha)
head(csv2_beta)
strcsv <-'"chain","well","cdr3"\n"alpha","1","CAVTGGDKLIF"\n"alpha","1","CALDGDKIIF"\n"alpha","2","CAVTGGDKLIF"\n"beta","1","CASGLARAEQYF"\n"beta","2","CASSEGDKVIF"\n"beta","2","CSEVHTARTQYF"'
con <- textConnection(strcsv)
dat <- read_alphabetr(data = con)
dat
dat$alpha_lib[2]
dat$beta_lib[3]
set.seed(290)
clonal <- create_clones(numb_beta = 1000,
dual_beta = 0.05,
dual_alpha = .3,
alpha_sharing = c(0.80, 0.15, 0.05),
beta_sharing = c(0.75, 0.20, 0.05))
ordered_clones <- clonal$ordered
random_clones <- clonal$TCR
dual_alpha <- clonal$dual_alpha
dual_beta <- clonal$dual_beta
random_clones[5:7, ]
random_clones[49:50, ]
random_clones[47:48, ]
share_alph <- c(.816, .085, .021, .007, .033, .005, .033)
share_beta <- c(.859, .076, .037, .019, .009)
set.seed(258)
TCR_pairings <- create_clones(numb_beta = 1787,
dual_beta = 0.06,
dual_alpha = 0.3,
alpha_sharing = share_alph,
beta_sharing = share_beta)
TCR_clones <- TCR_pairings$TCR
numb_cells <- matrix(c(50, 480), ncol = 2)
numb_cells <- matrix(c(100, 200, 48, 48), ncol = 2)
number_plates <- 5
err_drop <- c(0.15, .01)
err_seq <- c(0.02, .005)
err_mode <- c("constant", "constant")
number_skewed <- 25
pct_top <- 0.5
dis_behavior <- "linear"
numb_cells <- matrix(c(20, 50, 100, 200, 300,
128, 64, 96, 96, 96), ncol = 2)
data_tcr <- create_data(TCR = TCR_clones,
plates = number_plates,
error_drop = err_drop,
error_seq = err_seq,
error_mode = err_mode,
skewed = number_skewed,
prop_top = pct_top,
dist = dis_behavior,
numb_cells = numb_cells)
data_alph <- data_tcr$alpha
data_beta <- data_tcr$beta
pairs <- bagpipe(alpha = data_alph, beta = data_beta, rep = 5)
head(pairs)
pairs <- pairs[pairs[, "prop_replicates"] > .3, ]
head(pairs)
freq_init <- freq_estimate(alpha = data_alph,
beta = data_beta,
pair = pairs,
error = 0.15,
numb_cells = numb_cells)
head(freq_init)
common_dual <- dual_top(alpha = data_alph,
beta = data_beta,
pair = freq_init,
error = err,
numb_cells = numb_cells)
tail_dual <- dual_tail(alpha = data_alph,
beta = data_beta,
freq_results = freq_init,
numb_cells = numb_cells)
clones_dual <- rbind(common_dual, tail_dual)
head(clones_dual)
freq_dual <- freq_estimate(alpha = data_alph,
beta = data_beta,
pair = clones_dual,
error = 0.15,
numb_cells = numb_cells)
tcrpairs <- combine_freq_results(freq_init, freq_dual)
head(tcrpairs)
dual_res <- dual_eval(duals = clones_dual,
pair = freq_init,
TCR = TCR_pairings$TCR,
number_skewed = number_skewed,
TCR_dual = TCR_pairings$dual_alpha)
dual_res$fdr
dual_res$adj_depth_top
dual_res$adj_depth_tail
freq_res <- freq_eval(freq = tcrpairs,
number_skewed = number_skewed,
TCR = TCR_pairings$TCR,
numb_clones = nrow(TCR_pairings$TCR),
prop_top = pct_top)
freq_res$cv
freq_res$correct
|
test_that("random_resised_crop", {
img <- torch::torch_randn(3, 224, 224)
o <- transform_random_resized_crop(img, size = c(32, 32))
expect_tensor_shape(o, c(3, 32,32))
im <- magick::image_read("torch.png")
o <- transform_random_resized_crop(im, size = c(32, 32))
expect_tensor_shape(transform_to_tensor(o), c(3, 32, 32))
})
|
G6FFun<-function(df,model,G6Ftext2){
data<-sapply(df,as.character)
dP1<-data[-1,which(data[1,]=="P1")];P1<-as.numeric(dP1[which(is.na(as.numeric(dP1))==FALSE)]);df11<-as.data.frame(P1)
dF1<-data[-1,which(data[1,]=="F1")];F1<-as.numeric(dF1[which(is.na(as.numeric(dF1))==FALSE)]);df21<-as.data.frame(F1)
dP2<-data[-1,which(data[1,]=="P2")];P2<-as.numeric(dP2[which(is.na(as.numeric(dP2))==FALSE)]);df31<-as.data.frame(P2)
dB12<-data[-1,which(data[1,]=="B12")];B12<-as.numeric(dB12[which(is.na(as.numeric(dB12))==FALSE)]);df41<-as.data.frame(B12)
dB22<-data[-1,which(data[1,]=="B22")];B22<-as.numeric(dB22[which(is.na(as.numeric(dB22))==FALSE)]);df51<-as.data.frame(B22)
dF23<-data[-1,which(data[1,]=="F23")];F23<-as.numeric(dF23[which(is.na(as.numeric(dF23))==FALSE)]);df61<-as.data.frame(F23)
G6Fcolname<-c("Model","Log_Max_likelihood_value","AIC","mean[P1]","mean[F1]","mean[P2]","Var(P1 & P2 & F1)","B1:2-mean[1]","B1:2-mean[2]","B1:2-mean[3]","B1:2-mean[4]",
"B1:2-Var[1]","B1:2-Var[2]","B1:2-Var[3]","B1:2-Var[4]","B1:2-Proportion[1]","B1:2-Proportion[2]","B1:2-Proportion[3]","B1:2-Proportion[4]",
"B2:2-mean[1]","B2:2-mean[2]","B2:2-mean[3]","B2:2-mean[4]","B2:2-Var[1]","B2:2-Var[2]","B2:2-Var[3]","B2:2-Var[4]",
"B2:2-Proportion[1]","B2:2-Proportion[2]","B2:2-Proportion[3]","B2:2-Proportion[4]",
"F2:3-mean[1]","F2:3-mean[2]","F2:3-mean[3]","F2:3-mean[4]","F2:3-mean[5]","F2:3-mean[6]","F2:3-mean[7]","F2:3-mean[8]","F2:3-mean[9]",
"F2:3-Var[1]","F2:3-Var[2]","F2:3-Var[3]","F2:3-Var[4]","F2:3-Var[5]","F2:3-Var[6]","F2:3-Var[7]","F2:3-Var[8]","F2:3-Var[9]",
"F2:3-Proportion[1]","F2:3-Proportion[2]","F2:3-Proportion[3]","F2:3-Proportion[4]","F2:3-Proportion[5]","F2:3-Proportion[6]","F2:3-Proportion[7]","F2:3-Proportion[8]","F2:3-Proportion[9]",
"m1(m)","m2","m3","m4","m5","m6","da","db","ha","hb","i","jab","jba","l","[d]","[h]",
"B1:2-Major-Gene Var","B1:2-Heritability(Major-Gene)(%)","B1:2-Polygenes Var","B1:2-Heritability(Polygenes)(%)",
"B2:2-Major-Gene Var","B2:2-Heritability(Major-Gene)(%)","B2:2-Polygenes Var","B2:2-Heritability(Polygenes)(%)",
"F2:3-Major-Gene Var","F2:3-Heritability(Major-Gene)(%)","F2:3-Polygenes Var","F2:3-Heritability(Polygenes)(%)",
"U1 square(P1)","P(U1 square(P1))","U2 square(P1)","P(U2 square(P1))","U3 square(P1)","P(U3 square(P1))","nW square(P1)","P(nW square(P1))","Dn(P1)","P(Dn(P1))",
"U1 square(F1)","P(U1 square(F1))","U2 square(F1)","P(U2 square(F1))","U3 square(F1)","P(U3 square(F1))","nW square(F1)","P(nW square(F1))","Dn(F1)","P(Dn(F1))",
"U1 square(P2)","P(U1 square(P2))","U2 square(P2)","P(U2 square(P2))","U3 square(P2)","P(U3 square(P2))","nW square(P2)","P(nW square(P2))","Dn(P2)","P(Dn(P2))",
"U1 square(B1:2)","P(U1 square(B1:2))","U2 square(B1:2)","P(U2 square(B1:2))","U3 square(B1:2)","P(U3 square(B1:2))","nW square(B1:2)","P(nW square(B1:2))","Dn(B1:2)","P(Dn(B1:2))",
"U1 square(B2:2)","P(U1 square(B2:2))","U2 square(B2:2)","P(U2 square(B2:2))","U3 square(B2:2)","P(U3 square(B2:2))","nW square(B2:2)","P(nW square(B2:2))","Dn(B2:2)","P(Dn(B2:2))",
"U1 square(F2:3)","P(U1 square(F2:3))","U2 square(F2:3)","P(U2 square(F2:3))","U3 square(F2:3)","P(U3 square(F2:3))","nW square(F2:3)","P(nW square(F2:3))","Dn(F2:3)","P(Dn(F2:3))")
G6FModelFun<-list(NA)
G6FModelFun[[1]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0;sigma1[1]<-sigma
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2*a1,mean[4]-2*a1))
sigma2[2]<-sigma
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5]-2*a2))
sigma3[1]<-sigma3[3]<-sigma
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2*a3,mean[6],mean[6]-2*a3))
b1<-0.5*(mean[1]-mean[3])
b2<-(-6*mean[1]+10*mean[2]-6*mean[3]+2*mean1[2])/11
sigma1[2]<-sigma+(0.5*b1^2+0.25*b2^2)/n_fam
sigma2[1]<-sigma1[2];sigma3[2]<-sigma1[2]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
s0<-matrix(0,6,1); n0<-matrix(0,6,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[2]
s0[3]<-sumx[3]+sumwx2[2]+sumwx3[3];s0[4]<-sumwx1[2]+sumwx2[1]+sumwx3[2]
n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2;n0[2]<-n_samF1
n0[3]<-n_samP2+mix_pi2[2]*n_samB2+mix_pi3[3]*n_samF2;n0[4]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
n0[c(1:4)][abs(n0[c(1:4)])<0.00000001]<-0.000001
aa3<-s0[1]/n0[1]+s0[3]/n0[3]+2*s0[2]/n0[2]-4*s0[4]/n0[4];aa4<-sigma*(1/n0[1]+1/n0[3]+4/n0[2])
aa1<-1000;n_iter<-0
while (aa1>0.0001)
{
n_iter<-n_iter+1
aa1<-0.5*(mean[1]-mean[3])
aa2<-(-6*mean[1]+10*mean[2]-6*mean[3]+2*mean1[2])/11
sigma1[2]<-sigma+(0.5*aa1^2+0.25*aa2^2)/n_fam
aa2<-aa4+16*sigma1[2]/n0[4]
aaa1<-aa3/aa2
mean[1]<-(s0[1]-aaa1*sigma)/n0[1]
mean[2]<-(s0[2]-2*aaa1*sigma)/n0[2]
mean[3]<-(s0[3]-aaa1*sigma)/n0[3]
mean1[2]<-(s0[4]+4*aaa1*sigma1[2])/n0[4]
aa1<-abs(aaa1-aaa0)
aaa0<-aaa1
if(n_iter>20)break
}
mean1[1]<-mean3[1]<-mean[1];mean2[1]<-mean3[2]<-mean1[2];mean2[2]<-mean3[3]<-mean[3]
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[5]<-ss1+ss2+ss3+swx1[1]+swx2[2]+swx3[1]+swx3[3]
n0[5]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[2]*n_samB2+(mix_pi3[1]+mix_pi3[3])*n_samF2
s0[6]<-swx1[2]+swx2[1]+swx3[2];n0[6]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
aaa0<-sigma
a<-0.5*(mean[1]-mean[3])
aa2<-(-6*mean[1]+10*mean[2]-6*mean[3]+2*mean1[2])/11
a<-(0.5*a*a+0.25*aa2*aa2)/n_fam
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma/(sigma+a)
sigma<-(s0[5]+aa2*aa2*s0[6])/(n0[5]+aa2*n0[6])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[2]<-sigma+a;sigma2[1]<-sigma1[2];sigma3[2]<-sigma1[2]
sigma1[1]<-sigma2[2]<-sigma3[1]<-sigma3[3]<-sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*4
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,0,1,0,1,1,-1,0,1,0,0.5),4,3,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[2]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("1MG-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B[1],4)," "," "," "," "," ",round(B[2],4)," ",round(B[3],4)," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[2]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0;sigma1[1]<-sigma
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2*a1,mean[4]-2*a1))
sigma2[2]<-sigma
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5]-2*a2))
sigma3[1]<-sigma;sigma3[3]<-sigma
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2*a3,mean[6],mean[6]-2*a3))
b1<-0.5*(mean[1]-mean[3])
sigma1[2]<-sigma+(0.5*b1^2)/n_fam;sigma2[1]<-sigma1[2];sigma3[2]<-sigma1[2]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
n0<-matrix(0,6,1);s0<-matrix(0,6,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sumwx1[2]+sumwx2[1]+sumwx3[2]
s0[3]<-sumx[3]+sumwx2[2]+sumwx3[3];n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2;n0[3]<-n_samP2+mix_pi2[2]*n_samB2+mix_pi3[3]*n_samF2
n0[c(1:3)][abs(n0[c(1:3)])<0.00000001]<-0.000001
aa2<-1000;n_iter<-0
while (aa2>0.0001)
{
n_iter<-n_iter+1
aa1<-0.5*(mean[1]-mean[3])
sigma1[2]<-sigma+0.5*aa1^2/n_fam
s0[2]<-sumx[2]+s0[2]*sigma/sigma1[2]
n0[2]<-n_samF1+n0[2]*sigma/sigma1[2]
aa3<-s0[1]/n0[1]-2*s0[2]/n0[2]+s0[3]/n0[3]
aa4<-sigma*(1/n0[1]+4/n0[2]+1/n0[3])
aaa1<-aa3/aa4
mean[1]<-(s0[1]-aaa1*sigma)/n0[1]
mean[2]<-(s0[2]+2*aaa1*sigma)/n0[2]
mean[3]<-(s0[3]-aaa1*sigma)/n0[3]
aa2<-abs(aaa1-aaa0)
aaa0<-aaa1
if(n_iter>20)break
}
mean1[1]<-mean3[1]<-mean[1];mean1[2]<-mean2[1]<-mean3[2]<-mean[2];mean2[2]<-mean3[3]<-mean[3]
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[5]<-ss1+ss2+ss3+swx1[1]+swx2[2]+swx3[1]+swx3[3]
n0[5]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[2]*n_samB2+(mix_pi3[1]+mix_pi3[3])*n_samF2
s0[6]<-swx1[2]+swx2[1]+swx3[2]
n0[6]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
aaa0<-sigma
aa1<-0.5*(mean[1]-mean[3])
aa1<-0.5*aa1*aa1/n_fam
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma/(sigma+aa1)
sigma<-(s0[5]+aa2^2*s0[6])/(n0[5]+aa2*n0[6])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[2]<-sigma+aa1
sigma2[1]<-sigma3[2]<-sigma1[2]
sigma1[1]<-sigma2[2]<-sigma3[1]<-sigma3[3]<-sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*3
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3];sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,1,-1),3,2,byrow=T)
mm<-mean[c(1:3)]
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("1MG-A",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B[1],4)," "," "," "," "," ",round(B[2],4)," "," "," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[3]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0;sigma1[1]<-sigma
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2*a1,mean[4]-2*a1))
sigma2[2]<-sigma
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5]-2*a2))
sigma3[1]<-sigma3[3]<-sigma
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2*a3,mean[6],mean[6]-2*a3))
a1<-(5*mean[1]-7*mean[3]+2*mean1[2])/13
sigma1[2]<-sigma+(0.75*a1^2)/n_fam
sigma2[1]<-sigma3[2]<-sigma1[2]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
s0<-matrix(0,5,1);n0<-matrix(0,5,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumx[2]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[3]+sumwx2[2]+sumwx3[3]
s0[3]<-sumwx1[2]+sumwx2[1]+sumwx3[2];n0[1]<-n_samP1+n_samF1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-n_samP2+mix_pi2[2]*n_samB2+mix_pi3[3]*n_samF2;n0[3]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
n0[c(1:3)][abs(n0[c(1:3)])<0.00000001]<-0.000001
aa2<-3*s0[1]/n0[1]+s0[2]/n0[2]-4*s0[3]/n0[3];aa3<-9*sigma/n0[1]+sigma/n0[2]
aa1<-1000;n_iter<-0
while (aa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(5*mean[1]-7*mean[3]+2*mean1[2])/13
sigma1[2]<-sigma+0.75*aa1^2/n_fam
aaa1<-aa2/(aa3+16*sigma1[2]/n0[3])
mean[1]<-(s0[1]-3*aaa1*sigma)/n0[1]
mean[3]<-(s0[2]-aaa1*sigma)/n0[2]
mean1[2]<-(s0[3]+4*aaa1*sigma1[2])/n0[3]
aa1<-abs(aaa1-aaa0)
aaa0<-aaa1
if(n_iter>20)break
}
mean[2]<-mean1[1]<-mean3[1]<-mean[1];mean2[1]<-mean3[2]<-mean1[2];mean2[2]<-mean3[3]<-mean[3]
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[4]<-ss1+ss2+ss3+swx1[1]+swx2[2]+swx3[1]+swx3[3]
n0[4]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[2]*n_samB2+(mix_pi3[1]+mix_pi3[3])*n_samF2
aaa0<-sigma
s0[5]<-swx1[2]+swx2[1]+swx3[2]
n0[5]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
aa1<-(5*mean[1]-7*mean[3]+2*mean1[2])/13
aa1<-0.75*aa1^2/n_fam
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma/(sigma+aa1)
sigma<-(s0[4]+aa2^2*s0[5])/(n0[4]+aa2*n0[5])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[2]<-sigma+aa1
sigma2[1]<-sigma3[2]<-sigma1[2]
sigma1[1]<-sigma2[2]<-sigma3[1]<-sigma3[3]<-sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*3
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,-1,1,0.5),3,2,byrow=T)
mm<-as.matrix(c(mean[1],mean[3],mean1[2]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("1MG-EAD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B[1],4)," "," "," "," "," ",round(B[2],4)," ",round(B[2],4)," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[4]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0;sigma1[1]<-sigma
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2*a1,mean[4]-2*a1))
sigma2[2]<-sigma
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5]-2*a2))
sigma3[1]<-sigma3[3]<-sigma
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2*a3,mean[6],mean[6]-2*a3))
b1<-(7*mean[1]-5*mean[3]-2*mean1[2])/13
sigma1[2]<-sigma+0.75*b1^2/n_fam;sigma2[1]<-sigma3[2]<-sigma1[2]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
s0<-matrix(0,5,1);n0<-matrix(0,5,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[2]+sumx[3]+sumwx2[2]+sumwx3[3]
s0[3]<-sumwx1[2]+sumwx2[1]+sumwx3[2];n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-n_samF1+n_samP2+mix_pi2[2]*n_samB2+mix_pi3[3]*n_samF2;n0[3]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
n0[c(1:3)][abs(n0[c(1:3)])<0.00000001]<-0.000001
aa2<-s0[1]/n0[1]+3*s0[2]/n0[2]-4*s0[3]/n0[3]
aa3<-sigma*(1/n0[1]+9/n0[2])
aa1<-1000;n_iter<-0
while (aa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(7*mean[1]-5*mean[3]-2*mean1[2])/13
sigma1[2]<-sigma+0.75*aa1^2/n_fam
aaa1<-aa2/(aa3+16*sigma1[2]/n0[3])
mean[1]<-(s0[1]-aaa1*sigma)/n0[1]
mean[3]<-(s0[2]-3*aaa1*sigma)/n0[2]
mean1[2]<-(s0[3]+4*aaa1*sigma1[2])/n0[3]
aa1<-abs(aaa1-aaa0)
aaa0<-aaa1
if(n_iter>20)break
}
mean[2]<-mean2[2]<-mean3[3]<-mean[3];mean1[1]<-mean3[1]<-mean[1];mean2[1]<-mean3[2]<-mean1[2]
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[4]<-ss1+ss2+ss3+swx1[1]+swx2[2]+swx3[1]+swx3[3]
n0[4]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[2]*n_samB2+(mix_pi3[1]+mix_pi3[3])*n_samF2
s0[5]<-swx1[2]+swx2[1]+swx3[2]
n0[5]<-mix_pi1[2]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[2]*n_samF2
aaa0<-sigma
aa1<-(7*mean[1]-5*mean[3]-2*mean1[2])/13
aa1<-0.75*aa1^2/n_fam
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma/(sigma+aa1)
sigma<-(s0[4]+aa2^2*s0[5])/(n0[4]+aa2*n0[5])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[2]<-sigma+aa1;sigma2[1]<-sigma3[2]<-sigma1[2]
sigma1[1]<-sigma2[2]<-sigma3[1]<-sigma3[3]<-sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*3
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,-1,1,-0.5),3,2,byrow=T)
mm<-as.matrix(c(mean[1],mean[3],mean1[2]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("1MG-NCD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B[1],4)," "," "," "," "," ",round(B[2],4)," ",round(-B[2],4)," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[5]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigma/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2.4*a1,mean[4]+0.8*a1,mean[4]-0.8*a1,mean[4]-2.4*a1))
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2.4*a2,mean[5]+0.8*a2,mean[5]-0.8*a2,mean[5]-2.4*a2))
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2.4*a3,mean[6]+1.8*a3,mean[6]+1.2*a3,mean[6]+0.6*a3,mean[6],mean[6]-0.6*a3,mean[6]-1.2*a3,mean[6]-1.8*a3,mean[6]-2.4*a3))
gs<-matrix(0,8,1)
gs[1]<-0.25*(mean[1]-mean[3]+mean3[3]-mean3[7])
gs[2]<-0.25*(mean[1]-mean[3]-mean3[3]+mean3[7])
gs[3]<-(-8*mean[1]-2*mean[2]-8*mean[3]-2*mean1[2]+15*mean1[3]+8*mean1[4]+15*mean2[2]-2*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[4]<-(-8*mean[1]-2*mean[2]-8*mean[3]+15*mean1[2]-2*mean1[3]+8*mean1[4]-2*mean2[2]+15*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[5]<-0.25*(mean[1]+mean[3]-mean3[3]-mean3[7])
gs[6]<--0.5*mean[1]+0.5*mean[3]+mean1[2]-mean2[3]-0.5*mean3[3]+0.5*mean3[7]
gs[7]<--0.5*mean[1]+0.5*mean[3]+mean1[3]-mean2[2]+0.5*mean3[3]-0.5*mean3[7]
gs[8]<-(12*mean[1]+20*mean[2]+12*mean[3]-14*mean1[2]-14*mean1[3]-12*mean1[4]-14*mean2[2]-14*mean2[3]+12*mean3[3]+12*mean3[7])/17
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa5
sigma2[1]<-sigma1[4];sigma2[2]<-sigma+g_aa3;sigma2[3]<-sigma+g_aa4;sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma1[2];sigma3[4]<-sigma1[3];sigma3[5]<-sigma1[4];sigma3[6]<-sigma2[2];sigma3[8]<-sigma2[3]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
s0<-matrix(0,16,1);n0<-matrix(0,16,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[2]
s0[3]<-sumx[3]+sumwx2[4]+sumwx3[9];s0[4]<-sumwx1[2]+sumwx3[2]
s0[5]<-sumwx1[3]+sumwx3[4];s0[6]<-sumwx1[4]+sumwx2[1]+sumwx3[5]
s0[7]<-sumwx2[2]+sumwx3[6];s0[8]<-sumwx2[3]+sumwx3[8]
s0[9]<-sumwx3[3];s0[10]<-sumwx3[7]
n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2;n0[2]<-n_samF1
n0[3]<-n_samP2+mix_pi2[4]*n_samB2+mix_pi3[9]*n_samF2;n0[4]<-mix_pi1[2]*n_samB1+mix_pi3[2]*n_samF2
n0[5]<-mix_pi1[3]*n_samB1+mix_pi3[4]*n_samF2;n0[6]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
n0[7]<-mix_pi2[2]*n_samB2+mix_pi3[6]*n_samF2;n0[8]<-mix_pi2[3]*n_samB2+mix_pi3[8]*n_samF2
n0[9]<-mix_pi3[3]*n_samF2;n0[10]<-mix_pi3[7]*n_samF2
s0[c(1:10)][abs(s0[c(1:10)])<0.000001]<-0.000001
n0[c(1:10)][abs(n0[c(1:10)])<0.000001]<-0.000001
aa3<-s0[1]/n0[1]-4*s0[2]/n0[2]+s0[3]/n0[3]-4*s0[4]/n0[4]-4*s0[5]/n0[5]+16*s0[6]/n0[6]-4*s0[7]/n0[7]-4*s0[8]/n0[8]+s0[9]/n0[9]+s0[10]/n0[10]
aa4<-sigma*(1/n0[1]+16/n0[2]+1/n0[3]+1/n0[9]+1/n0[10])
aa1<-1000;n_iter<-0
while (aa1>0.0001)
{
n_iter<-n_iter+1
gs[1]<-0.25*(mean[1]-mean[3]+mean3[3]-mean3[7])
gs[2]<-0.25*(mean[1]-mean[3]-mean3[3]+mean3[7])
gs[3]<-(-8*mean[1]-2*mean[2]-8*mean[3]-2*mean1[2]+15*mean1[3]+
8*mean1[4]+15*mean2[2]-2*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[4]<-(-8*mean[1]-2*mean[2]-8*mean[3]+15*mean1[2]-2*mean1[3]+
8*mean1[4]-2*mean2[2]+15*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[5]<-0.25*(mean[1]+mean[3]-mean3[3]-mean3[7])
gs[6]<--0.5*mean[1]+0.5*mean[3]+mean1[2]-mean2[3]-0.5*mean3[3]+0.5*mean3[7]
gs[7]<--0.5*mean[1]+0.5*mean[3]+mean1[3]-mean2[2]+0.5*mean3[3]-0.5*mean3[7]
gs[8]<-(12*mean[1]+20*mean[2]+12*mean[3]-14*mean1[2]-14*mean1[3]-
12*mean1[4]-14*mean2[2]-14*mean2[3]+12*mean3[3]+12*mean3[7])/17
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa5
sigma2[1]<-sigma1[4];sigma2[2]<-sigma+g_aa3;sigma2[3]<-sigma+g_aa4;sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma1[2];sigma3[4]<-sigma1[3];sigma3[5]<-sigma1[4];sigma3[6]<-sigma2[2];sigma3[8]<-sigma2[3]
aa2<-aa4+16*sigma1[2]/n0[4]+16*sigma1[3]/n0[5]+256*sigma1[4]/n0[6]+16*sigma2[2]/n0[7]+16*sigma2[3]/n0[8]
aaa1<-aa3/aa2
mean[1]<-(s0[1]-aaa1*sigma)/n0[1]
mean[2]<-(s0[2]+4*aaa1*sigma)/n0[2]
mean[3]<-(s0[3]-aaa1*sigma)/n0[3]
mean1[2]<-(s0[4]+4*aaa1*sigma1[2])/n0[4]
mean1[3]<-(s0[5]+4*aaa1*sigma1[3])/n0[5]
mean1[4]<-(s0[6]-16*aaa1*sigma1[4])/n0[6]
mean2[2]<-(s0[7]+4*aaa1*sigma2[2])/n0[7]
mean2[3]<-(s0[8]+4*aaa1*sigma2[3])/n0[8]
mean3[3]<-(s0[9]-aaa1*sigma)/n0[9]
mean3[7]<-(s0[10]-aaa1*sigma)/n0[10]
mean1[1]<-mean[1]
mean2[1]<-mean1[4];mean2[4]<-mean[3]
mean3[1]<-mean[1];mean3[2]<-mean1[2];mean3[4]<-mean1[3]
mean3[5]<-mean1[4];mean3[6]<-mean2[2];mean3[8]<-mean2[3];mean3[9]<-mean[3]
aa1<-abs(aaa1-aaa0)
aaa0<-aaa1
if(n_iter>20)break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2} ;for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[11]<-ss1+ss2+ss3+swx1[1]+swx2[4]+swx3[1]+swx3[3]+swx3[7]+swx3[9]
n0[11]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[4]*n_samB2+(mix_pi3[1]+mix_pi3[3]+mix_pi3[7]+mix_pi3[9])*n_samF2
s0[12]<-swx1[2]+swx3[2]
s0[13]<-swx1[3]+swx3[4]
s0[14]<-swx1[4]+swx2[1]+swx3[5]
s0[15]<-swx2[2]+swx3[6]
s0[16]<-swx2[3]+swx3[8]
n0[12]<-mix_pi1[2]*n_samB1+mix_pi3[2]*n_samF2
n0[13]<-mix_pi1[3]*n_samB1+mix_pi3[4]*n_samF2
n0[14]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
n0[15]<-mix_pi2[2]*n_samB2+mix_pi3[6]*n_samF2
n0[16]<-mix_pi2[3]*n_samB2+mix_pi3[8]*n_samF2
gs[1]<-0.25*(mean[1]-mean[3]+mean3[3]-mean3[7])
gs[2]<-0.25*(mean[1]-mean[3]-mean3[3]+mean3[7])
gs[3]<-(-8*mean[1]-2*mean[2]-8*mean[3]-2*mean1[2]+15*mean1[3]+
8*mean1[4]+15*mean2[2]-2*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[4]<-(-8*mean[1]-2*mean[2]-8*mean[3]+15*mean1[2]-2*mean1[3]+
8*mean1[4]-2*mean2[2]+15*mean2[3]-8*mean3[3]-8*mean3[7])/17
gs[5]<-0.25*(mean[1]+mean[3]-mean3[3]-mean3[7])
gs[6]<--0.5*mean[1]+0.5*mean[3]+mean1[2]-mean2[3]-0.5*mean3[3]+0.5*mean3[7]
gs[7]<--0.5*mean[1]+0.5*mean[3]+mean1[3]-mean2[2]+0.5*mean3[3]-0.5*mean3[7]
gs[8]<-(12*mean[1]+20*mean[2]+12*mean[3]-14*mean1[2]-14*mean1[3]-
12*mean1[4]-14*mean2[2]-14*mean2[3]+12*mean3[3]+12*mean3[7])/17
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
aaa0<-sigma;aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma/(sigma+g_aa1);aa2<-sigma/(sigma+g_aa2)
aa3<-sigma/(sigma+g_aa5);aa4<-sigma/(sigma+g_aa3)
aa5<-sigma/(sigma+g_aa4)
sigma<-(s0[11]+aa1^2*s0[12]+aa2^2*s0[13]+aa3^2*s0[14]+aa4^2*s0[15]+aa5^2*s0[16])/(n0[11]+aa1*n0[12]+aa2*n0[13]+aa3*n0[14]+aa4*n0[15]+aa5*n0[16])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa5
sigma2[1]<-sigma1[4];sigma2[2]<-sigma+g_aa3;sigma2[3]<-sigma+g_aa4;sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma1[2];sigma3[4]<-sigma1[3];sigma3[5]<-sigma1[4]
sigma3[6]<-sigma2[2];sigma3[8]<-sigma2[3]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*10
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,0,1,0,0,0,1,0,0,1,1,0,0,0,1,1,-1,-1,0,0,1,0,0,0,
1,1,0,0,0.5,0,0.5,0,0,1,0,1,0.5,0,0,0,0.5,0,1,0,0,0.5,0.5,0,0,0,0.25,
1,0,-1,0.5,0,0,0,-0.5,0,1,-1,0,0,0.5,0,-0.5,0,0,1,1,-1,0,0,-1,0,0,0,
1,-1,1,0,0,-1,0,0,0),10,9,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[2],mean1[3],mean1[4],mean2[2],mean2[3],mean3[3],mean3[7]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-ADI",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B[1],4)," "," "," "," "," ",round(B[2],4),round(B[3],4),round(B[4],4),round(B[5],4),round(B[6],4),round(B[7],4),round(B[8],4),round(B[9],4)," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[6]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625));sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2.4*a1,mean[4]+0.8*a1,mean[4]-0.8*a1,mean[4]-2.4*a1))
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2.4*a2,mean[5]+0.8*a2,mean[5]-0.8*a2,mean[5]-2.4*a2))
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2.4*a3,mean[6]+1.8*a3,mean[6]+1.2*a3,mean[6]+0.6*a3,mean[6],mean[6]-0.6*a3,mean[6]-1.2*a3,mean[6]-1.8*a3,mean[6]-2.4*a3))
gs<-matrix(0,4,1)
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
gs[3]<--mean[1]/7+3*mean[2]/7-mean[3]/7-0.5*mean1[2]+0.5*mean1[3]+
mean1[4]/7+0.5*mean2[2]-0.5*mean2[3]-mean3[3]/7-mean3[7]/7
gs[4]<--mean[1]/7+3*mean[2]/7-mean[3]/7+0.5*mean1[2]-0.5*mean1[3]+
mean1[4]/7-0.5*mean2[2]+0.5*mean2[3]-mean3[3]/7-mean3[7]/7
g_aa1<-(0.5*gs[2]^2+0.25*gs[4]^2)/n_fam
g_aa2<-(0.5*gs[1]^2+0.25*gs[3]^2)/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
s0<-matrix(0,14,1);n0<-matrix(0,14,1)
hh<-matrix(0,5,5);b_line<-matrix(0,5,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[2]
s0[3]<-sumx[3]+sumwx2[4]+sumwx3[9];s0[4]<-sumwx1[2]+sumwx3[2]
s0[5]<-sumwx1[3]+sumwx3[4];s0[6]<-sumwx1[4]+sumwx2[1]+sumwx3[5]
s0[7]<-sumwx2[2]+sumwx3[6];s0[8]<-sumwx2[3]+sumwx3[8]
s0[9]<-sumwx3[3];s0[10]<-sumwx3[7]
n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2;n0[2]<-n_samF1
n0[3]<-n_samP2+mix_pi2[4]*n_samB2+mix_pi3[9]*n_samF2;n0[4]<-mix_pi1[2]*n_samB1+mix_pi3[2]*n_samF2
n0[5]<-mix_pi1[3]*n_samB1+mix_pi3[4]*n_samF2;n0[6]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
n0[7]<-mix_pi2[2]*n_samB2+mix_pi3[6]*n_samF2;n0[8]<-mix_pi2[3]*n_samB2+mix_pi3[8]*n_samF2
n0[9]<-mix_pi3[3]*n_samF2;n0[10]<-mix_pi3[7]*n_samF2
s0[c(1:10)][abs(s0[c(1:10)])<0.000001]<-0.000001;n0[c(1:10)][abs(n0[c(1:10)])<0.000001]<-0.000001
n_iter<-0;aaa1<-1000;AA<-matrix(0,5,1)
while (aaa1>0.0001)
{
n_iter<-n_iter+1
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
gs[3]<--mean[1]/7+3*mean[2]/7-mean[3]/7-0.5*mean1[2]+0.5*mean1[3]+
mean1[4]/7+0.5*mean2[2]-0.5*mean2[3]-mean3[3]/7-mean3[7]/7
gs[4]<--mean[1]/7+3*mean[2]/7-mean[3]/7+0.5*mean1[2]-0.5*mean1[3]+
mean1[4]/7-0.5*mean2[2]+0.5*mean2[3]-mean3[3]/7-mean3[7]/7
g_aa1<-(0.5*gs[2]^2+0.25*gs[4]^2)/n_fam
g_aa2<-(0.5*gs[1]^2+0.25*gs[3]^2)/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma1[3];sigma3[5]<-sigma1[4];sigma3[6]<-sigma1[3]
hh[1,1]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])
hh[1,2]<-sigma*(1/n0[1]-1/n0[3]-1/n0[9]+1/n0[10])
hh[1,3]<-sigma*(1/n0[1]-1/n0[3]+1/n0[9]-1/n0[10])
hh[1,4]<-sigma*(5/n0[1]+19/n0[3])
hh[1,5]<-sigma*(1/n0[1]+1/n0[3])
hh[2,2]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])+sigma1[2]*(4/n0[4]+4/n0[8])
hh[2,3]<-sigma*(1/n0[1]+1/n0[3]-1/n0[9]-1/n0[10])
hh[2,4]<-sigma*(5/n0[1]-19/n0[3])-28*sigma1[2]/n0[8]
hh[2,5]<-sigma*(1/n0[1]-1/n0[3])
hh[3,3]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])+sigma1[3]*(4/n0[5]+4/n0[7])
hh[3,4]<-sigma*(5/n0[1]-19/n0[3])-28*sigma1[3]/n0[7]
hh[3,5]<-sigma*(1/n0[1]-1/n0[3])
hh[4,4]<-sigma*(25/n0[1]+100/n0[2]+361/n0[3])+196*sigma1[3]/n0[7]+196*sigma1[2]/n0[8]+36*sigma1[4]/n0[6]
hh[4,5]<-sigma*(5/n0[1]+20/n0[2]+19/n0[3])+24*sigma1[4]/n0[6]
hh[5,5]<-sigma*(1/n0[1]+4/n0[2]+1/n0[3])+16*sigma1[4]/n0[6]
for(i in 2:5)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-s0[1]/n0[1]+s0[3]/n0[3]-s0[9]/n0[9]-s0[10]/n0[10]
b_line[2]<-s0[1]/n0[1]-s0[3]/n0[3]-2*s0[4]/n0[4]+2*s0[8]/n0[8]+s0[9]/n0[9]-s0[10]/n0[10]
b_line[3]<-s0[1]/n0[1]-s0[3]/n0[3]-2*s0[5]/n0[5]+2*s0[7]/n0[7]-s0[9]/n0[9]+s0[10]/n0[10]
b_line[4]<-5*s0[1]/n0[1]+10*s0[2]/n0[2]+19*s0[3]/n0[3]-14*s0[7]/n0[7]-14*s0[8]/n0[8]-6*s0[6]/n0[6]
b_line[5]<-s0[1]/n0[1]+2*s0[2]/n0[2]+s0[3]/n0[3]-4*s0[6]/n0[6]
B<-solve(hh,b_line)
mean[1]<-(s0[1]-sigma*(B[1]+B[2]+B[3]+5*B[4]+B[5]))/n0[1]
mean[2]<-(s0[2]-sigma*(10*B[4]+2*B[5]))/n0[2]
mean[3]<-(s0[3]-sigma*(B[1]-B[2]-B[3]+19*B[4]+B[5]))/n0[3]
mean1[2]<-(s0[4]+2*B[2]*sigma1[2])/n0[4]
mean1[3]<-(s0[5]+2*B[3]*sigma1[3])/n0[5]
mean1[4]<-(s0[6]+sigma1[4]*(6*B[4]+4*B[5]))/n0[6]
mean2[2]<-(s0[7]-sigma1[3]*(2*B[3]-14*B[4]))/n0[7]
mean2[3]<-(s0[8]-sigma1[2]*(2*B[2]-14*B[4]))/n0[8]
mean3[3]<-(s0[9]+sigma*(B[1]-B[2]+B[3]))/n0[9]
mean3[7]<-(s0[10]+sigma*(B[1]+B[2]-B[3]))/n0[10]
mean1[1]<-mean[1];mean2[1]<-mean1[4];mean2[4]<-mean[3]
mean3[1]<-mean[1];mean3[2]<-mean1[2];mean3[4]<-mean1[3]
mean3[5]<-mean1[4];mean3[6]<-mean2[2];mean3[8]<-mean2[3];mean3[9]<-mean[3]
aaa1<-max(abs(B-AA))
AA<-B
if(n_iter>20)break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[11]<-ss1+ss2+ss3+swx1[1]+swx2[4]+swx3[1]+swx3[3]+swx3[7]+swx3[9]
n0[11]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[4]*n_samB2+(mix_pi3[1]+mix_pi3[3]+mix_pi3[7]+mix_pi3[9])*n_samF2
s0[12]<-swx1[2]+swx2[3]+swx3[2]+swx3[8];s0[13]<-swx1[3]+swx2[2]+swx3[4]+swx3[6];s0[14]<-swx1[4]+swx2[1]+swx3[5]
n0[12]<-mix_pi1[2]*n_samB1+mix_pi2[3]*n_samB2+mix_pi3[2]*n_samF2+mix_pi3[8]*n_samF2
n0[13]<-mix_pi1[3]*n_samB1+mix_pi2[2]*n_samB2+mix_pi3[4]*n_samF2+mix_pi3[6]*n_samF2
n0[14]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
gs[3]<--mean[1]/7+3*mean[2]/7-mean[3]/7-0.5*mean1[2]+0.5*mean1[3]+
mean1[4]/7+0.5*mean2[2]-0.5*mean2[3]-mean3[3]/7-mean3[7]/7
gs[4]<--mean[1]/7+3*mean[2]/7-mean[3]/7+0.5*mean1[2]-0.5*mean1[3]+
mean1[4]/7-0.5*mean2[2]+0.5*mean2[3]-mean3[3]/7-mean3[7]/7
g_aa1<-(0.5*gs[2]^2+0.25*gs[4]^2)/n_fam
g_aa2<-(0.5*gs[1]^2+0.25*gs[3]^2)/n_fam
g_aa3<-g_aa1+g_aa2
aaa0<-sigma;aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma/(sigma+g_aa1)
aa2<-sigma/(sigma+g_aa2)
aa3<-sigma/(sigma+g_aa3)
sigma<-(s0[11]+aa1^2*s0[12]+aa2^2*s0[13]+aa3^2*s0[14])/(n0[11]+aa1*n0[12]+aa2*n0[13]+aa3*n0[14])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*6
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,0,1,0,0,1,1,1,-1,-1,0,0,1,1,0,0,0.5,1,0,1,0.5,0,1,0,0,0.5,0.5,
1,0,-1,0.5,0,1,-1,0,0,0.5,1,1,-1,0,0,1,-1,1,0,0),10,5,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[2],mean1[3],mean1[4],mean2[2],mean2[3],mean3[3],mean3[7]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4),round(B1[4],4),round(B1[5],4)," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[7]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2.4*a1,mean[4]+0.8*a1,mean[4]-0.8*a1,mean[4]-2.4*a1))
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2.4*a2,mean[5]+0.8*a2,mean[5]-0.8*a2,mean[5]-2.4*a2))
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2.4*a3,mean[6]+1.8*a3,mean[6]+1.2*a3,mean[6]+0.6*a3,mean[6],mean[6]-0.6*a3,mean[6]-1.2*a3,mean[6]-1.8*a3,mean[6]-2.4*a3))
gs<-matrix(0,2,1)
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
sigma1[1]<-sigma
g_aa1<-0.5*gs[2]^2/n_fam
g_aa2<-0.5*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
s0<-matrix(0,14,1);n0<-matrix(0,14,1)
hh<-matrix(0,6,6);b_line<-matrix(0,6,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-sigma1[4]*sumx[2]+sigma*(sumwx1[4]+sumwx2[1]+sumwx3[5])
s0[3]<-sumx[3]+sumwx2[4]+sumwx3[9];s0[4]<-sumwx1[2]+sumwx3[2]
s0[5]<-sumwx1[3]+sumwx3[4];s0[7]<-sumwx2[2]+sumwx3[6]
s0[8]<-sumwx2[3]+sumwx3[8];s0[9]<-sumwx3[3];s0[10]<-sumwx3[7]
n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-n_samF1*sigma1[4]+sigma*(mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2)
n0[3]<-n_samP2+mix_pi2[4]*n_samB2+mix_pi3[9]*n_samF2
n0[4]<-mix_pi1[2]*n_samB1+mix_pi3[2]*n_samF2;n0[5]<-mix_pi1[3]*n_samB1+mix_pi3[4]*n_samF2
n0[7]<-mix_pi2[2]*n_samB2+mix_pi3[6]*n_samF2;n0[8]<-mix_pi2[3]*n_samB2+mix_pi3[8]*n_samF2
n0[9]<-mix_pi3[3]*n_samF2;n0[10]<-mix_pi3[7]*n_samF2
s0[c(1:10)][abs(s0[c(1:10)])<0.000001]<-0.000001;n0[c(1:10)][abs(n0[c(1:10)])<0.000001]<-0.000001
AA<-matrix(0,6,1);aaa1<-1000;n_iter<-0
while (aaa1>0.0001)
{
n_iter<-n_iter+1
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
sigma1[1]<-sigma
g_aa1<-0.5*gs[2]^2/n_fam
g_aa2<-0.5*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
hh[1,1]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])
hh[1,2]<-sigma*(1/n0[1]-1/n0[3]-1/n0[9]+1/n0[10])
hh[1,3]<-sigma*(1/n0[1]-1/n0[3]+1/n0[9]-1/n0[10])
hh[1,4]<-0
hh[1,5]<-0
hh[1,6]<-sigma*(1/n0[9]+1/n0[10])
hh[2,2]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])+sigma1[2]*(4/n0[4]+4/n0[8])
hh[2,3]<-sigma*(1/n0[1]+1/n0[3]-1/n0[9]-1/n0[10])
hh[2,4]<-2*sigma1[2]*(1/n0[4]-1/n0[8])
hh[2,5]<-sigma1[2]*(-2/n0[4]+2/n0[8])
hh[2,6]<-sigma*(-1/n0[9]+1/n0[10])
hh[3,3]<-sigma*(1/n0[1]+1/n0[3]+1/n0[9]+1/n0[10])+sigma1[3]*(4/n0[5]+4/n0[7])
hh[3,4]<-2*sigma1[3]*(1/n0[5]-1/n0[7])
hh[3,5]<-2*sigma1[3]*(1/n0[5]-1/n0[7])
hh[3,6]<-sigma*(1/n0[9]-1/n0[10])
hh[4,4]<-16*sigma*sigma1[4]/n0[2]+sigma1[2]/n0[4]+sigma1[3]/n0[5]+sigma1[3]/n0[7]+sigma1[2]/n0[8]
hh[4,5]<-sigma1[3]*(1/n0[5]+1/n0[7])-sigma1[2]*(1/n0[4]+1/n0[8])
hh[4,6]<-8*sigma*sigma1[4]/n0[2]
hh[5,5]<-sigma1[2]*(1/n0[4]+1/n0[8])+sigma1[3]*(1/n0[5]+1/n0[7])
hh[5,6]<-0
hh[6,6]<-sigma*(4*sigma1[4]/n0[2]+1/n0[9]+1/n0[10])
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-s0[1]/n0[1]+s0[3]/n0[3]-s0[9]/n0[9]-s0[10]/n0[10]
b_line[2]<-s0[1]/n0[1]-s0[3]/n0[3]-2*s0[4]/n0[4]+2*s0[8]/n0[8]+s0[9]/n0[9]-s0[10]/n0[10]
b_line[3]<-s0[1]/n0[1]-s0[3]/n0[3]-2*s0[5]/n0[5]+2*s0[7]/n0[7]-s0[9]/n0[9]+s0[10]/n0[10]
b_line[4]<-4*s0[2]/n0[2]-s0[4]/n0[4]-s0[5]/n0[5]-s0[7]/n0[7]-s0[8]/n0[8]
b_line[5]<-s0[4]/n0[4]-s0[5]/n0[5]-s0[7]/n0[7]+s0[8]/n0[8]
b_line[6]<-2*s0[2]/n0[2]-s0[9]/n0[9]-s0[10]/n0[10]
B<-solve(hh,b_line)
mean[1]<-(s0[1]-sigma*(B[1]+B[2]+B[3]))/n0[1]
mean[2]<-(s0[2]-sigma*sigma1[4]*(4*B[4]+2*B[6]))/n0[2]
mean[3]<-(s0[3]-sigma*(B[1]-B[2]-B[3]))/n0[3]
mean1[2]<-(s0[4]+(2*B[2]+B[4]-B[5])*sigma1[2])/n0[4]
mean1[3]<-(s0[5]+(2*B[3]+B[4]+B[5])*sigma1[3])/n0[5]
mean2[2]<-(s0[7]-sigma1[3]*(2*B[3]-B[4]-B[5]))/n0[7]
mean2[3]<-(s0[8]-sigma1[2]*(2*B[2]-B[4]+B[5]))/n0[8]
mean3[3]<-(s0[9]+sigma*(B[1]-B[2]+B[3]+B[6]))/n0[9]
mean3[7]<-(s0[10]+sigma*(B[1]+B[2]-B[3]+B[6]))/n0[10]
mean1[1]<-mean[1];mean1[4]<-mean2[1]<-mean[2]
mean2[4]<-mean[3]
mean3[1]<-mean[1];mean3[2]<-mean1[2];mean3[4]<-mean1[3];mean3[5]<-mean[2]
mean3[6]<-mean2[2];mean3[8]<-mean2[3];mean3[9]<-mean[3]
aaa1<-max(abs(B-AA))
AA<-B
if(n_iter>20)break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[11]<-ss1+ss2+ss3+swx1[1]+swx2[4]+swx3[1]+swx3[3]+swx3[7]+swx3[9]
n0[11]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[4]*n_samB2+(mix_pi3[1]+mix_pi3[3]+mix_pi3[7]+mix_pi3[9])*n_samF2
s0[12]<-swx1[2]+swx2[3]+swx3[2]+swx3[8]
s0[13]<-swx1[3]+swx2[2]+swx3[4]+swx3[6]
s0[14]<-swx1[4]+swx2[1]+swx3[5]
n0[12]<-mix_pi1[2]*n_samB1+mix_pi2[3]*n_samB2+mix_pi3[2]*n_samF2+mix_pi3[8]*n_samF2
n0[13]<-mix_pi1[3]*n_samB1+mix_pi2[2]*n_samB2+mix_pi3[4]*n_samF2+mix_pi3[6]*n_samF2
n0[14]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
gs[1]<-(mean[1]-mean[3]+mean1[2]-mean2[3]+mean3[3]-mean3[7])/6
gs[2]<-(mean[1]-mean[3]+mean1[3]-mean2[2]-mean3[3]+mean3[7])/6
g_aa1<-0.5*gs[2]^2/n_fam
g_aa2<-0.5*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
aaa0<-sigma;aa4<-1000;n_iter<-0
while (aa4>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma/(sigma+g_aa1)
aa2<-sigma/(sigma+g_aa2)
aa3<-sigma/(sigma+g_aa3)
sigma<-(s0[11]+aa1*aa1*s0[12]+aa2*aa2*s0[13]+aa3*aa3*s0[14])/(n0[11]+aa1*n0[12]+aa2*n0[13]+aa3*n0[14])
aa4<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1
sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3]
sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*4
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,1,0,0,1,-1,-1,1,1,0,1,0,1,
1,0,-1,1,-1,0,1,1,-1,1,-1,1),9,3,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[2],mean1[3],mean2[2],mean2[3],mean3[3],mean3[7]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-A",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4)," "," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[8]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-as.matrix(c(0.25,0.5,0.25))
mean1<-as.matrix(c(mean[1],mean[4],mean[2]))
sigma1<-matrix(0,3,1)
mi2<-as.matrix(c(0.25,0.5,0.25))
mean2<-as.matrix(c(mean[2],mean[5],mean[3]))
sigma2<-matrix(0,3,1)
mi3<-as.matrix(c(0.0625,0.125,0.25,0.25,0.25,0.0625))
mean3<-as.matrix(c(mean[1],mean[2],mean1[2],mean[2],mean2[2],mean[3]))
sigma3<-matrix(0,6,1)
sigma<-sigma0
b1<-a1<-0.2*mean[1]-0.2*mean[3]+0.1*mean1[2]-0.1*mean2[2]
a1<-b1^2/n_fam
sigma1[1]<-sigma;sigma1[2]<-sigma+0.5*a1;sigma1[3]<-sigma+a1
sigma2[1]<-sigma1[3];sigma2[2]<-sigma1[2];sigma2[3]<-sigma
sigma3[1]<-sigma3[2]<-sigma3[6]<-sigma
sigma3[3]<-sigma3[5]<-sigma1[2]
sigma3[4]<-sigma1[3]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,3,n_samB1); swx1 <- matrix(0,3,1)
W2 <- matrix(0,3,n_samB2); swx2 <- matrix(0,3,1)
W3 <- matrix(0,6,n_samF2); swx3 <- matrix(0,6,1)
s0<-matrix(0,8,1);n0<-matrix(0,8,1)
hh<-matrix(0,3,3);b_line<-matrix(0,3,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:3) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:3) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:6) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumwx1[1]+sumwx3[1];s0[2]<-(sumx[2]+sumwx3[2])*sigma1[3]+sigma*(sumwx1[3]+sumwx2[1]+sumwx3[4])
s0[3]<-sumx[3]+sumwx2[3]+sumwx3[6];s0[4]<-sumwx1[2]+sumwx3[3]
s0[5]<-sumwx2[2]+sumwx3[5]
n0[1]<-n_samP1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-(n_samF1+mix_pi3[2]*n_samF2)*sigma1[3]+sigma*(mix_pi1[3]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[4]*n_samF2)
n0[3]<-n_samP2+mix_pi2[3]*n_samB2+mix_pi3[6]*n_samF2
n0[4]<-mix_pi1[2]*n_samB1+mix_pi3[3]*n_samF2
n0[5]<-mix_pi2[2]*n_samB2+mix_pi3[5]*n_samF2
n0[c(1:5)][abs(n0[c(1:5)])<0.00000001]<-0.000001
AA<-matrix(0,3,1);aa3<-0;aa4<-0;aaa1<-1000
while(aaa1>0.0001)
{
aa4<-aa4+1
aa6<-0.2*mean[1]-0.2*mean[3]+0.1*mean1[2]-0.1*mean2[2]
aa6<-aa6^2/n_fam
sigma1[2]<-sigma+0.5*aa6
sigma1[3]<-sigma+aa6
hh[1,1]<-sigma/n0[1]+4*sigma*sigma1[3]/n0[2]+sigma/n0[3]
hh[1,2]<-4*sigma*sigma1[3]/n0[2]
hh[1,3]<-sigma/n0[1]+6*sigma*sigma1[3]/n0[2]
hh[2,2]<-sigma1[2]/n0[4]+4*sigma*sigma1[3]/n0[2]+sigma1[2]/n0[5]
hh[2,3]<-6*sigma*sigma1[3]/n0[2]+2*sigma1[2]/n0[5]
hh[3,3]<-sigma/n0[1]+9*sigma*sigma1[3]/n0[2]+4*sigma1[2]/n0[5]
for(i in 2:3)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-s0[1]/n0[1]-2*s0[2]/n0[2]+s0[3]/n0[3]
b_line[2]<-s0[4]/n0[4]-2*s0[2]/n0[2]+s0[5]/n0[5]
b_line[3]<-s0[1]/n0[1]-3*s0[2]/n0[2]+2*s0[5]/n0[5]
B<-solve(hh,b_line)
mean[1]<-(s0[1]-sigma*(B[1]+B[3]))/n0[1]
mean[2]<-(s0[2]+sigma*sigma1[3]*(2*B[1]+2*B[2]+3*B[3]))/n0[2]
mean[3]<-(s0[3]-B[1]*sigma)/n0[3]
mean1[2]<-(s0[4]-B[2]*sigma1[2])/n0[4]
mean2[2]<-(s0[5]-(B[2]+2*B[3])*sigma1[2])/n0[5]
aaa1<-max(abs(B-AA))
AA<-B
if (aa4>20) break
}
mean1[1]<-mean[1];mean1[3]<-mean[2]
mean2[1]<-mean[2];mean2[3]<-mean[3]
mean3[1]<-mean[1]
mean3[2]<-mean3[4]<-mean[2]
mean3[3]<-mean1[2];mean3[5]<-mean2[2];mean3[6]<-mean[3]
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:3) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:3) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:6) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[6]<-ss1+ss2+ss3+swx1[1]+swx2[3]+swx3[1]+swx3[2]+swx3[6]
n0[6]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[3]*n_samB2+(mix_pi3[1]+mix_pi3[2]+mix_pi3[6])*n_samF2
s0[7]<-swx1[2]+swx2[2]+swx3[3]+swx3[5]
s0[8]<-swx1[3]+swx2[1]+swx3[4]
n0[7]<-mix_pi1[2]*n_samB1+mix_pi2[2]*n_samB2+(mix_pi3[3]+mix_pi3[5])*n_samF2
n0[8]<-mix_pi1[3]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[4]*n_samF2
aa6<-0.2*mean[1]-0.2*mean[3]+0.1*mean1[2]-0.1*mean2[2]
aa6<-aa6*aa6/n_fam
aaa0<-sigma;aa4<-0;aa3<-1000
while (aa3>0.0001)
{
aa4<-aa4+1
aa1<-sigma/(sigma+0.5*aa6)
aa2<-sigma/(sigma+aa6)
sigma<-(s0[6]+aa1^2*s0[7]+aa2^2*s0[8])/(n0[6]+aa1*n0[7]+aa2*n0[8])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if (aa4>20) break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+0.5*aa6;sigma1[3]<-sigma+aa6
sigma2[1]<-sigma1[3];sigma2[2]<-sigma1[2];sigma2[3]<-sigma
sigma3[1]<-sigma3[2]<-sigma3[6]<-sigma
sigma3[3]<-sigma3[5]<-sigma1[2]
sigma3[4]<-sigma1[3]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*3
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,3)
for(i in 1:3){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,3)
for(i in 1:3){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,6)
for(i in 1:6){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,2,1,0,1,-2,1,1,1,-1),5,2,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[2],mean2[2]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[3]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-EA",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," ",round(t(sigma1),4)," ",
round(t(mix_pi1),4)," ",round(t(mean2),4)," ",round(t(sigma2),4)," ",round(t(mix_pi2),4)," ",
round(t(mean3),4)," "," "," ",round(t(sigma3),4)," "," "," ",round(t(mix_pi3),4)," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[2],4)," "," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[9]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1);sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1)
if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[1],mean[4]-0.5*a1,mean[4]-1.5*a1,mean[4]-2.5*a1))
a2<-sqrt(sigmaB2/n_samB2)
if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean1[4],mean[5]-a2,mean[5]-2*a2,mean[3]))
a3<-sqrt(sigmaF2/n_samF2)
if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[1],mean1[2],mean[6],mean1[3],mean1[4],mean2[2],mean[6],mean2[3],mean[3]))
gs<-matrix(0,2,1)
gs[1]<-(5*mean[1]-7*mean[3]+5*mean1[2]+2*mean1[3]+2*mean1[4]+2*mean2[2]-7*mean2[3]+5*mean3[3]-7*mean3[7])/39
gs[2]<-(5*mean[1]-7*mean[3]+2*mean1[2]+5*mean1[3]+2*mean1[4]-7*mean2[2]+2*mean2[3]-7*mean3[3]+5*mean3[7])/39
g_aa1<-0.75*gs[2]^2/n_fam
g_aa2<-0.75*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
s0<-matrix(0,13,1);n0<-matrix(0,13,1)
hh<-matrix(0,6,6);b_line<-matrix(0,6,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumx[2]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[3]+sumwx2[4]+sumwx3[9]
s0[3]<-sumwx1[2]+sumwx3[2];s0[4]<-sumwx1[3]+sumwx3[4]
s0[5]<-sumwx1[4]+sumwx2[1]+sumwx3[5];s0[6]<-sumwx2[2]+sumwx3[6]
s0[7]<-sumwx2[3]+sumwx3[8];s0[8]<-sumwx3[3];s0[9]<-sumwx3[7]
n0[1]<-n_samP1+n_samF1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-n_samP2+mix_pi2[4]*n_samB2+mix_pi3[9]*n_samF2
n0[3]<-mix_pi1[2]*n_samB1+mix_pi3[2]*n_samF2
n0[4]<-mix_pi1[3]*n_samB1+mix_pi3[4]*n_samF2
n0[5]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
n0[6]<-mix_pi2[2]*n_samB2+mix_pi3[6]*n_samF2
n0[7]<-mix_pi2[3]*n_samB2+mix_pi3[8]*n_samF2
n0[8]<-mix_pi3[3]*n_samF2
n0[9]<-mix_pi3[7]*n_samF2
n0[c(1:9)][abs(n0[c(1:9)])<0.00000001]<-0.000001
AA<-matrix(0,6,1);aa7<-0;aaa1<-1000
while (aaa1>0.0001)
{
aa7<-aa7+1
gs[1]<-(5*mean[1]-7*mean[3]+5*mean1[2]+2*mean1[3]+2*mean1[4]+2*mean2[2]-7*mean2[3]+5*mean3[3]-7*mean3[7])/39
gs[2]<-(5*mean[1]-7*mean[3]+2*mean1[2]+5*mean1[3]+2*mean1[4]-7*mean2[2]+2*mean2[3]-7*mean3[3]+5*mean3[7])/39
g_aa1<-0.75*gs[2]^2/n_fam
g_aa2<-0.75*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
hh[1,1]<-sigma*(1/n0[1]+1/n0[2]+1/n0[8]+1/n0[9])
hh[1,2]<-sigma*(1/n0[1]-1/n0[2]-1/n0[8]+1/n0[9])
hh[1,3]<-sigma*(1/n0[1]-1/n0[2]+1/n0[8]-1/n0[9])
hh[1,4]<-sigma*(3/n0[1]+1/n0[2])
hh[1,5]<-sigma/n0[2]
hh[1,6]<-0
hh[2,2]<-sigma*(1/n0[1]+1/n0[2]+1/n0[8]+1/n0[9])+sigma1[2]*(4/n0[3]+4/n0[7])
hh[2,3]<-sigma*(1/n0[1]+1/n0[2]-1/n0[8]-1/n0[9])
hh[2,4]<-sigma*(3/n0[1]-1/n0[2])
hh[2,5]<--sigma/n0[2]-2*sigma1[2]/n0[7]
hh[2,6]<--6*sigma1[2]/n0[3]+2*sigma1[2]/n0[7]
hh[3,3]<-sigma*(1/n0[1]+1/n0[2]+1/n0[8]+1/n0[9])+sigma1[3]*(4/n0[4]+4/n0[6])
hh[3,4]<-sigma*(3/n0[1]-1/n0[2])
hh[3,5]<--sigma/n0[2]-2*sigma1[3]/n0[6]
hh[3,6]<-6*sigma1[3]/n0[4]-2*sigma1[3]/n0[6]
hh[4,4]<-sigma*(9/n0[1]+1/n0[2])+16*sigma1[4]/n0[5]
hh[4,5]<-sigma/n0[2]-4*sigma1[4]/n0[5]
hh[4,6]<-0
hh[5,5]<-sigma/n0[2]+sigma1[4]/n0[5]+sigma1[3]/n0[6]+sigma1[2]/n0[7]
hh[5,6]<-sigma1[3]/n0[6]-sigma1[2]/n0[7]
hh[6,6]<-9*sigma1[2]/n0[3]+9*sigma1[3]/n0[4]+sigma1[3]/n0[6]+sigma1[2]/n0[7]
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-s0[1]/n0[1]+s0[2]/n0[2]-s0[8]/n0[8]-s0[9]/n0[9]
b_line[2]<-s0[1]/n0[1]-s0[2]/n0[2]-2*s0[3]/n0[3]+2*s0[7]/n0[7]+s0[8]/n0[8]-s0[9]/n0[9]
b_line[3]<-s0[1]/n0[1]-s0[2]/n0[2]-2*s0[4]/n0[4]+2*s0[6]/n0[6]-s0[8]/n0[8]+s0[9]/n0[9]
b_line[4]<-3*s0[1]/n0[1]+s0[2]/n0[2]-4*s0[5]/n0[5]
b_line[5]<-s0[2]/n0[2]+s0[5]/n0[5]-s0[6]/n0[6]-s0[7]/n0[7]
b_line[6]<-3*s0[3]/n0[3]-3*s0[4]/n0[4]-s0[6]/n0[6]+s0[7]/n0[7]
B<-solve(hh,b_line)
mean[1]<-(s0[1]-sigma*(B[1]+B[2]+B[3]+3*B[4]))/n0[1]
mean[3]<-(s0[2]-sigma*(B[1]-B[2]-B[3]+B[4]+B[5]))/n0[2]
mean1[2]<-(s0[3]+(2*B[2]-3*B[6])*sigma1[2])/n0[3]
mean1[3]<-(s0[4]+(2*B[3]+3*B[6])*sigma1[3])/n0[4]
mean1[4]<-(s0[5]+sigma1[4]*(4*B[4]-B[5]))/n0[5]
mean2[2]<-(s0[6]-sigma1[3]*(2*B[3]-B[5]-B[6]))/n0[6]
mean2[3]<-(s0[7]-sigma1[2]*(2*B[2]-B[5]+B[6]))/n0[7]
mean3[3]<-(s0[8]+sigma*(B[1]-B[2]+B[3]))/n0[8]
mean3[7]<-(s0[9]+sigma*(B[1]+B[2]-B[3]))/n0[9]
mean[2]<-mean1[1]<-mean[1]
mean2[1]<-mean1[4];mean2[4]<-mean[3]
mean3[1]<-mean[1];mean3[2]<-mean1[2];mean3[4]<-mean1[3]
mean3[5]<-mean1[4];mean3[6]<-mean2[2];mean3[8]<-mean2[3];mean3[9]<-mean[3]
aaa1<-max(abs(B-AA))
AA<-B
if (aa7>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[10]<-ss1+ss2+ss3+swx1[1]+swx2[4]+swx3[1]+swx3[3]+swx3[7]+swx3[9]
n0[10]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[4]*n_samB2+(mix_pi3[1]+mix_pi3[3]+mix_pi3[7]+mix_pi3[9])*n_samF2
s0[11]<-swx1[2]+swx2[3]+swx3[2]+swx3[8]
s0[12]<-swx1[3]+swx2[2]+swx3[4]+swx3[6]
s0[13]<-swx1[4]+swx2[1]+swx3[5]
n0[11]<-mix_pi1[2]*n_samB1+mix_pi2[3]*n_samB2+mix_pi3[2]*n_samF2+mix_pi3[8]*n_samF2
n0[12]<-mix_pi1[3]*n_samB1+mix_pi2[2]*n_samB2+mix_pi3[4]*n_samF2+mix_pi3[6]*n_samF2
n0[13]<-mix_pi1[4]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[5]*n_samF2
gs[1]<-(5*mean[1]-7*mean[3]+5*mean1[2]+2*mean1[3]+2*mean1[4]+2*mean2[2]-7*mean2[3]+5*mean3[3]-7*mean3[7])/39
gs[2]<-(5*mean[1]-7*mean[3]+2*mean1[2]+5*mean1[3]+2*mean1[4]-7*mean2[2]+2*mean2[3]-7*mean3[3]+5*mean3[7])/39
g_aa1<-0.75*gs[2]^2/n_fam
g_aa2<-0.75*gs[1]^2/n_fam
g_aa3<-g_aa1+g_aa2
aaa0<-sigma;aa7<-0;aa3<-1000
while (aa3>0.0001)
{
aa7<-aa7+1
aa1<-sigma/(sigma+g_aa1)
aa2<-sigma/(sigma+g_aa2)
aa3<-sigma/(sigma+g_aa3)
sigma<-(s0[10]+aa1^2*s0[11]+aa2^2*s0[12]+aa3^2*s0[13])/(n0[10]+aa1*n0[11]+aa2*n0[12]+aa3*n0[13])
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if (aa7>20) break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2;sigma1[4]<-sigma+g_aa3
sigma2[1]<-sigma1[4];sigma2[2]<-sigma1[3];sigma2[3]<-sigma1[2];sigma2[4]<-sigma
sigma3[1]<-sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma
sigma3[2]<-sigma3[8]<-sigma1[2]
sigma3[4]<-sigma3[6]<-sigma1[3]
sigma3[5]<-sigma1[4]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*4
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,1,-1,-1,1,1,0.5,1,0.5,1,1,0.5,0.5,
1,0.5,-1,1,-1,0.5,1,1,-1,1,-1,1),9,3,byrow=T)
mm<-as.matrix(c(mean[1],mean[3],mean1[2],mean1[3],mean1[4],mean2[2],mean2[3],mean3[3],mean3[7]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-CD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4),round(B1[2],4),round(B1[3],4)," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[10]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-as.matrix(c(0.25,0.5,0.25));sigma1<-matrix(0,3,1)
mi2<-as.matrix(c(0.25,0.5,0.25));sigma2<-matrix(0,3,1)
mi3<-as.matrix(c(0.0625,0.125,0.25,0.25,0.25,0.0625))
sigma3<-matrix(0,6,1);sigma<-sigma0
a1<-sqrt(sigma40/(n_samB1-1))
if (mean[1]<mean[3]) {a1<--a1}
mean1<-as.matrix(c(mean[1],mean[4]-a1,mean[4]))
mean2<-as.matrix(c(mean1[3],mean[5],mean[3]))
mean3<-as.matrix(c(mean[1],mean[6],mean1[2],mean1[3],mean2[2],mean[3]))
a1<-(10*mean[1]-14*mean[3]+7*mean1[2]+4*mean1[3]-5*mean2[2]-2*mean3[2])/65
a1<-a1^2/n_fam
sigma1[1]<-sigma;sigma1[2]<-sigma+0.75*a1;sigma1[3]<-sigma+1.5*a1
sigma2[1]<-sigma1[3];sigma2[2]<-sigma1[2];sigma2[3]<-sigma
sigma3[1]<-sigma3[2]<-sigma3[6]<-sigma
sigma3[3]<-sigma3[5]<-sigma1[2]
sigma3[4]<-sigma1[3]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,3,n_samB1); swx1 <- matrix(0,3,1)
W2 <- matrix(0,3,n_samB2); swx2 <- matrix(0,3,1)
W3 <- matrix(0,6,n_samF2); swx3 <- matrix(0,6,1)
s0<-matrix(0,9,1);n0<-matrix(0,9,1)
hh<-matrix(0,4,4);b_line<-matrix(0,4,1)
gs<-matrix(0,1,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:3) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:3) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:6) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
aaa0<-0
s0[1]<-sumx[1]+sumx[2]+sumwx1[1]+sumwx3[1];s0[2]<-sumx[3]+sumwx2[3]+sumwx3[6]
s0[3]<-sumwx1[2]+sumwx3[3];s0[4]<-sumwx1[3]+sumwx2[1]+sumwx3[4]
s0[5]<-sumwx2[2]+sumwx3[5];s0[6]<-sumwx3[2]
n0[1]<-n_samP1+n_samF1+mix_pi1[1]*n_samB1+mix_pi3[1]*n_samF2
n0[2]<-n_samP2+mix_pi2[3]*n_samB2+mix_pi3[6]*n_samF2
n0[3]<-mix_pi1[2]*n_samB1+mix_pi3[3]*n_samF2
n0[4]<-mix_pi1[3]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[4]*n_samF2
n0[5]<-mix_pi2[2]*n_samB2+mix_pi3[5]*n_samF2
n0[6]<-mix_pi3[2]*n_samF2
n0[c(1:6)][abs(n0[c(1:6)])<0.00000001]<-0.000001
AA<-matrix(0,4,1);ab5<-0;aaa1<-1000
while(aaa1>0.0001)
{
ab5<-ab5+1
gs[1]<-(10*mean[1]-14*mean[3]+7*mean1[2]+4*mean1[3]-5*mean2[2]-2*mean3[2])/65
g_aa1<-0.75*gs[1]*gs[1]/n_fam
g_aa2<-1.5*gs[1]*gs[1]/n_fam
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2
sigma2[1]<-sigma1[3];sigma2[2]<-sigma1[2];sigma2[3]<-sigma
sigma3[1]<-sigma3[2]<-sigma3[6]<-sigma
sigma3[3]<-sigma3[5]<-sigma1[2]
sigma3[4]<-sigma1[3]
hh[1,1]<-sigma*(1/n0[1]+1/n0[2]+4/n0[6])
hh[1,2]<-sigma*(1/n0[1]-1/n0[2])
hh[1,3]<-sigma*(3/n0[1]+1/n0[2])
hh[1,4]<-sigma/n0[2]
hh[2,2]<-sigma*(1/n0[1]+1/n0[2])+sigma1[2]*(4/n0[3]+4/n0[5])
hh[2,3]<-sigma*(3/n0[1]-1/n0[2])
hh[2,4]<--sigma/n0[2]-4*sigma1[2]/n0[5]
hh[3,3]<-sigma*(9/n0[1]+1/n0[2])+16*sigma1[3]/n0[4]
hh[3,4]<-sigma/n0[2]-4*sigma1[3]/n0[4]
hh[4,4]<-sigma/n0[2]+sigma1[3]/n0[4]+4*sigma1[2]/n0[5]
for(i in 2:4)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-s0[1]/n0[1]+s0[2]/n0[2]-2*s0[6]/n0[6]
b_line[2]<-s0[1]/n0[1]-s0[2]/n0[2]-2*s0[3]/n0[3]+2*s0[5]/n0[5]
b_line[3]<-3*s0[1]/n0[1]+s0[2]/n0[2]-4*s0[4]/n0[4]
b_line[4]<-s0[2]/n0[2]+s0[4]/n0[4]-2*s0[5]/n0[5]
B<-solve(hh,b_line)
mean[1]<-(s0[1]-sigma*(B[1]+B[2]+3*B[3]))/n0[1]
mean[3]<-(s0[2]-sigma*(B[1]-B[2]+B[3]+B[4]))/n0[2]
mean1[2]<-(s0[3]+2*B[2]*sigma1[2])/n0[3]
mean1[3]<-(s0[4]+(4*B[3]-B[4])*sigma1[3])/n0[4]
mean2[2]<-(s0[5]-sigma1[2]*(2*B[2]-2*B[4]))/n0[5]
mean3[2]<-(s0[6]+2*sigma*B[1])/n0[6]
mean[2]<-mean1[1]<-mean[1]
mean2[1]<-mean1[3];mean2[3]<-mean[3]
mean3[1]<-mean[1];mean3[3]<-mean1[2]
mean3[4]<-mean1[3];mean3[5]<-mean2[2];mean3[6]<-mean[3]
aaa1<-max(abs(B-AA))
AA<-B
if (ab5>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:3) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:3) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:6) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
s0[7]<-ss1+ss2+ss3+swx1[1]+swx2[3]+swx3[1]+swx3[2]+swx3[6]
n0[7]<-n_samP1+n_samF1+n_samP2+mix_pi1[1]*n_samB1+mix_pi2[3]*n_samB2+(mix_pi3[1]+mix_pi3[2]+mix_pi3[6])*n_samF2
s0[8]<-swx1[2]+swx2[2]+swx3[3]+swx3[5]
s0[9]<-swx1[3]+swx2[1]+swx3[4]
n0[8]<-mix_pi1[2]*n_samB1+mix_pi2[2]*n_samB2+mix_pi3[3]*n_samF2+mix_pi3[5]*n_samF2
n0[9]<-mix_pi1[3]*n_samB1+mix_pi2[1]*n_samB2+mix_pi3[4]*n_samF2
aaa0<-sigma
gs[1]<-(10*mean[1]-14*mean[3]+7*mean1[2]+4*mean1[3]-5*mean2[2]-2*mean3[2])/65
g_aa1<-0.75*gs[1]^2/n_fam
g_aa2<-1.5*gs[1]^2/n_fam
aa4<-1000;ab5<-0
while (aa4>0.0001)
{
ab5<-ab5+1
aa1<-sigma/(sigma+g_aa1)
aa2<-sigma/(sigma+g_aa2)
sigma<-(s0[7]+aa1^2*s0[8]+aa2^2*s0[9])/(n0[7]+aa1*n0[8]+aa2*n0[9])
aa4<-abs(sigma-aaa0)
aaa0<-sigma
if (ab5>20) break
}
sigma1[1]<-sigma;sigma1[2]<-sigma+g_aa1;sigma1[3]<-sigma+g_aa2
sigma2[1]<-sigma1[3];sigma2[2]<-sigma1[2];sigma2[3]<-sigma
sigma3[1]<-sigma3[2]<-sigma3[6]<-sigma
sigma3[3]<-sigma3[5]<-sigma1[2]
sigma3[4]<-sigma1[3]
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*3
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,3)
for(i in 1:3){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,3)
for(i in 1:3){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,6)
for(i in 1:6){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,2,1,-2,1,0.5,1,1,1,-0.5,1,0),6,2,byrow=T)
mm<-as.matrix(c(mean[1],mean[3],mean1[2],mean1[3],mean2[2],mean3[2]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 ) {jj1<-0}
ll1<-jj1/sigmaB1
jj2<-sigmaB2-sigma2[3]
if (jj2<0) {jj2<-0}
ll2<-jj2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0) {jj3<-0}
ll3<-jj3/sigmaF2
output <- data.frame("2MG-EAD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," ",round(t(sigma1),4)," ",
round(t(mix_pi1),4)," ",round(t(mean2),4)," ",round(t(sigma2),4)," ",round(t(mix_pi2),4)," ",
round(t(mean3),4)," "," "," ",round(t(sigma3),4)," "," "," ",round(t(mix_pi3),4)," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[2],4),round(B1[2],4),round(B1[2],4)," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4)," "," ",round(jj2,4),round(ll2*100,4)," "," ",round(jj3,4),round(ll3*100,4)," "," ",
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[11]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
sigma<-sigma0
mix_pi1<-matrix(1,1,1);mean1<-matrix(mean[4],1,1);sigma1<-matrix(0,1,1)
mix_pi2<-matrix(1,1,1);mean2<-matrix(mean[5],1,1);sigma2<-matrix(0,1,1)
mix_pi3<-matrix(1,1,1);mean3<-matrix(mean[6],1,1);sigma3<-matrix(0,1,1)
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dnorm(dataB1,mean1[1],sqrt(sigma40))))+
sum(log(dnorm(dataB2,mean2[1],sqrt(sigma50))))+sum(log(dnorm(dataF2,mean3[1],sqrt(sigma60))))
iteration <- 0; stopa <- 1000
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2)
ss2<-sum((dataF1-mean[2])^2);ss4<-sigma40*(n_samB1-1)
ss5<-sigma50*(n_samB2-1);ss6<-sigma60*(n_samF2-1)
abc1<-ss1+ss2+ss3;abc2<-n_samP1+n_samF1+n_samP2
aaa0<-sigma;aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma/sigma40
aa2<-sigma/sigma50
aa3<-sigma/sigma60
sigma<-(abc1+aa1^2*ss4+aa2^2*ss5+aa3^2*ss6)/(abc2+aa1*n_samB1+aa2*n_samB2+aa3*n_samF2)
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma_4<-sigma40-sigma;
if (sigma_4<0) {sigma_4<-0;sigma40<-sigma}
sigma40<-sigma_4+sigma
sigma_5<-sigma50-sigma;
if (sigma_5<0) {sigma_5<-0;sigma50<-sigma}
sigma50<-sigma_5+sigma
sigma_6<-sigma60-sigma;
if (sigma_6<0) {sigma_6<-0;sigma60<-sigma}
sigma60<-sigma_6+sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dnorm(dataB1,mean1[1],sqrt(sigma40))))+
sum(log(dnorm(dataB2,mean2[1],sqrt(sigma50))))+sum(log(dnorm(dataF2,mean3[1],sqrt(sigma60))))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*10
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
sigma1[1]<-sigma40;sigma2[1]<-sigma50;sigma3[1]<-sigma60
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,1)
for(i in 1:1){
B1gg <- (dataB1 - mean1[i])/sqrt(as.vector(sigma1[i]))
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,1)
for(i in 1:1){
B2gg <- (dataB2 - mean2[i])/sqrt(as.vector(sigma2[i]))
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,1)
for(i in 1:1){
F2gg <- (dataF2 - mean3[i])/sqrt(as.vector(sigma3[i]))
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
m1<-meanP1;m2<-meanF1;m3<-meanP2
m4<-mean1[1];m5<-mean2[1];m6<-mean3[1]
mm1<-sigma40-sigma
if (mm1<0 || mm1>=sigma40) {mm1<-0}
nn1<-mm1/sigma40
mm2<-sigma50-sigma
if (mm2<0 || mm2>=sigma50) {mm2<-0}
nn2<-mm2/sigma50
mm3<-sigma60-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigma60
output <- data.frame("PG-ADI",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4),round(sigma0,4),round(t(mean1),4)," "," "," ",round(t(sigma1),4)," "," "," ",
round(t(mix_pi1),4)," "," "," ",round(t(mean2),4)," "," "," ",round(t(sigma2),4)," "," "," ",round(t(mix_pi2),4)," "," "," ",
round(t(mean3),4)," "," "," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," "," "," ",
round(m1,4),round(m2,4),round(m3,4),round(m4,4),round(m5,4),round(m6,4)," "," "," "," "," "," "," "," "," "," "," "," ",
round(mm1,4),round(nn1*100,4)," "," ",round(mm2,4),round(nn2*100,4)," "," ",round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output)
return(OUTPUT)
}
G6FModelFun[[12]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
sigma<-sigma0
mix_pi1<-matrix(1,1,1);mean1<-matrix(mean[4],1,1);sigma1<-matrix(0,1,1)
mix_pi2<-matrix(1,1,1);mean2<-matrix(mean[5],1,1);sigma2<-matrix(0,1,1)
mix_pi3<-matrix(1,1,1);mean3<-matrix(mean[6],1,1);sigma3<-matrix(0,1,1)
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dnorm(dataB1,mean1[1],sqrt(sigma40))))+
sum(log(dnorm(dataB2,mean2[1],sqrt(sigma50))))+sum(log(dnorm(dataF2,mean3[1],sqrt(sigma60))))
iteration <- 0; stopa <- 1000
hh<-matrix(0,3,3);b_line<-matrix(0,3,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
aaa0<-0
sigma40<-sum((dataB1-mean[4])^2);sigma40<-sigma40/(n_samB1-1)
sigma50<-sum((dataB2-mean[5])^2);sigma50<-sigma50/(n_samB2-1)
sigma60<-sum((dataF2-mean[6])^2);sigma60<-sigma60/(n_samF2-1)
hh[1,1]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma40/n_samB1+4*sigma50/n_samB2
hh[1,2]<-3*sigma*(1/n_samP1-1/n_samP2)
hh[1,3]<--2*sigma40/n_samB1+2*sigma50/n_samB2
hh[2,2]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+64*sigma60/n_samF2
hh[2,3]<-16*sigma60/n_samF2
hh[3,3]<-sigma40/n_samB1+sigma50/n_samB2+4*sigma60/n_samF2
for(i in 2:3)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-sumx[1]/n_samP1-sumx[3]/n_samP2-2*sumx[4]/n_samB1+2*sumx[5]/n_samB2
b_line[2]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-8*sumx[6]/n_samF2
b_line[3]<-sumx[4]/n_samB1+sumx[5]/n_samB2-2*sumx[6]/n_samF2
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(B[1]+3*B[2]))/n_samP1
mean[2]<-(sumx[2]-2*sigma*B[2])/n_samF1
mean[3]<-(sumx[3]+sigma*(B[1]-3*B[2]))/n_samP2
mean1[1]<-(sumx[4]+sigma40*(2*B[1]-B[3]))/n_samB1
mean2[1]<-(sumx[5]-(2*B[1]+B[3])*sigma50)/n_samB2
mean3[1]<-(sumx[6]+(8*B[2]+2*B[3])*sigma60)/n_samF2
aaa0<-sigma
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
abc1<-ss1+ss2+ss3;abc2<-n_samP1+n_samF1+n_samP2
ss4<-sum((dataB1-mean[4])^2);ss5<-sum((dataB2-mean[5])^2);ss6<-sum((dataF2-mean[6])^2)
sigma40<-ss4/(n_samB1-1)
sigma_4<-sigma40-sigma;if (sigma_4<0) {sigma_4<-0}
sigma40<-sigma_4+sigma;sigma50<-ss5/(n_samB2-1)
sigma_5<-sigma50-sigma;if (sigma_5<0) {sigma_5<-0}
sigma50<-sigma_5+sigma;sigma60<-ss6/(n_samF2-1)
sigma_6<-sigma60-sigma;if (sigma_6<0) {sigma_6<-0}
sigma60<-sigma_6+sigma
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma/sigma40
if (aa1>=1) {aa1<-1}
aa2<-sigma/sigma50
if (aa2>=1) {aa2<-1}
aa3<-sigma/sigma60
if (aa3>=1) {aa3<-1}
aa4<-abc1+aa1^2*ss4+aa2^2*ss5+aa3^2*ss6
aa5<-abc2+aa1*n_samB1+aa2*n_samB2+aa3*n_samF2
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma40<-sigma_4+sigma;sigma50<-sigma_5+sigma;sigma60<-sigma_6+sigma
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dnorm(dataB1,mean1[1],sqrt(sigma40))))+
sum(log(dnorm(dataB2,mean2[1],sqrt(sigma50))))+sum(log(dnorm(dataF2,mean3[1],sqrt(sigma60))))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*7
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
sigma1[1]<-sigma40;sigma2[1]<-sigma50;sigma3[1]<-sigma60
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,1)
for(i in 1:1){
B1gg <- (dataB1 - mean1[i])/sqrt(as.vector(sigma1[i]))
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,1)
for(i in 1:1){
B2gg <- (dataB2 - mean2[i])/sqrt(as.vector(sigma2[i]))
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,1)
for(i in 1:1){
F2gg <- (dataF2 - mean3[i])/sqrt(as.vector(sigma3[i]))
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,0,1,0,1,1,-1,0,1,0.5,0.25,1,-0.5,0.25,1,0,0.25),6,3,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean2[1],mean3[1]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
mm1<-sigma40-sigma
if (mm1<0 || mm1>=sigma40) {mm1<-0}
nn1<-mm1/sigma40
mm2<-sigma50-sigma
if (mm2<0 || mm2>=sigma50) {mm2<-0}
nn2<-mm2/sigma50
mm3<-sigma60-sigma
if (mm3<0 || mm3>=sigma60) {mm3<-0}
nn3<-mm3/sigma60
output <- data.frame("PG-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," "," ",round(t(sigma1),4)," "," "," ",
round(t(mix_pi1),4)," "," "," ",round(t(mean2),4)," "," "," ",round(t(sigma2),4)," "," "," ",round(t(mix_pi2),4)," "," "," ",
round(t(mean3),4)," "," "," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," "," "," ",
round(B1[1],4)," "," "," "," "," "," "," "," "," "," "," "," "," ",round(B1[2],4),round(B1[3],4)," "," ",
round(mm1,4),round(nn1*100,4)," "," ",round(mm2,4),round(nn2*100,4)," "," ",round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output)
return(OUTPUT)
}
G6FModelFun[[13]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+a1,mean[4]))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5],mean[5]-a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+a3,mean[6],mean[6]-a3))
b1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
b2<--0.6*mean1[1]+0.6*mean1[2]+0.6*mean2[1]-0.6*mean2[2]-0.4*mean3[1]+0.8*mean3[2]-0.4*mean3[3]
b3<-(0.5*b1^2+0.25*b2^2)/n_fam
sigma1[1]<-sigmaB1/2;sigma1[2]<-sigma1[1]+b3
sigma2[2]<-sigmaB2/2;sigma2[1]<-sigma2[2]+b3
sigma3[1]<-sigmaF2/2;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+b3
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
n0<-matrix(0,9,1);s0<-matrix(0,9,1); rr<-matrix(0,2,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1
n0[3]<-mix_pi2[1]*n_samB2;n0[4]<-mix_pi2[2]*n_samB2
n0[5]<-mix_pi3[1]*n_samF2;n0[6]<-mix_pi3[2]*n_samF2
n0[7]<-mix_pi3[3]*n_samF2
n0[c(1:7)][abs(n0[c(1:7)])<0.0001]<-0.0001
aaa0<-0
s0[1]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/n0[5]+sumwx3[2]/n0[6]
s0[2]<-sumwx2[1]/n0[3]-sumwx2[2]/n0[4]-sumwx3[2]/n0[6]+sumwx3[3]/n0[7]
abc5<-0;abc6<-0;n_iter<-0;aaa1<-1000;AA<-matrix(0,2,1)
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa2<--0.6*mean1[1]+0.6*mean1[2]+0.6*mean2[1]-0.6*mean2[2]-0.4*mean3[1]+0.8*mean3[2]-0.4*mean3[3]
aa1<-(0.5*aa1*aa1+0.25*aa2*aa2)/n_fam
sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma2[2]+aa1
sigma3[2]<-sigma3[1]+aa1
abc1<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/n0[5]+sigma3[2]/n0[6]
abc2<--sigma3[2]/n0[6]
abc3<-sigma2[1]/n0[3]+sigma2[2]/n0[4]+sigma3[2]/n0[6]+sigma3[3]/n0[7]
aa2<-abc1*abc3-abc2^2
aa3<-s0[1]*abc3-s0[2]*abc2
aa4<-s0[2]*abc1-s0[1]*abc2
rr[1]<-aa3/aa2;rr[2]<-aa4/aa2
mean1[1]<-(sumwx1[1]-rr[1]*sigma1[1])/n0[1];mean1[2]<-(sumwx1[2]+rr[1]*sigma1[2])/n0[2]
mean2[1]<-(sumwx2[1]-rr[2]*sigma2[1])/n0[3];mean2[2]<-(sumwx2[2]+rr[2]*sigma2[2])/n0[4]
mean3[1]<-(sumwx3[1]+rr[1]*sigma3[1])/n0[5];mean3[2]<-(sumwx3[2]+sigma3[2]*(-rr[1]+rr[2]))/n0[6]
mean3[3]<-(sumwx3[3]-rr[2]*sigma3[3])/n0[7]
aaa1<-max(abs(rr-AA))
AA<-rr
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
n0[8]<-mix_pi1[1]*n_samB1;n0[9]<-mix_pi1[2]*n_samB1
aaa0<-sigma1[1];n_iter<-0;aa3<-1000
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa2<--0.6*mean1[1]+0.6*mean1[2]+0.6*mean2[1]-0.6*mean2[2]-0.4*mean3[1]+0.8*mean3[2]-0.4*mean3[3]
aa1<-(0.5*aa1^2+0.25*aa2^2)/n_fam
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab2<-sigma1[1]/(sigma1[1]+aa1)
sigma1[1]<-(swx1[1]+ab2^2*swx1[2])/(n0[8]+ab2*n0[9])
aa3<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+aa1
n0[8]<-mix_pi2[1]*n_samB2;n0[9]<-mix_pi2[2]*n_samB2
aaa0<-sigma2[2];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab3<-sigma2[2]/(sigma2[2]+aa1)
sigma2[2]<-(ab3^2*swx2[1]+swx2[2])/(ab3*n0[8]+n0[9])
aa3<-abs(sigma2[2]-aaa0)
aaa0<-sigma2[2]
if (n_iter>20) break
}
sigma50<-sigma2[2]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[2]<-sigma}
sigma2[2]<-sigma50+sigma;sigma2[1]<-sigma2[2]+aa1
n0[8]<-(mix_pi3[3]+mix_pi3[1])*n_samF2;n0[9]<-mix_pi3[2]*n_samF2
aaa0<-sigma3[1];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab4<-sigma3[1]/(sigma3[1]+aa1)
sigma3[1]<-(swx3[1]+ab4^2*swx3[2]+swx3[3])/(n0[8]+ab4*n0[9])
aa3<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
s0[1]<-ss1+ss2+ss3;s0[2]<-n_samP1+n_samF1+n_samP2
aaa0<-0;n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
abc1<-sigma/(sigma+sigma40)
abc2<-sigma/(sigma+sigma40+aa1)
abc3<-sigma/(sigma+sigma50+aa1)
abc4<-sigma/(sigma+sigma50)
abc5<-sigma/(sigma+sigma60)
abc6<-sigma/(sigma+sigma60+aa1)
aa4<-s0[1]+abc1^2*swx1[1]+abc2^2*swx1[2]+abc3^2*swx2[1]+abc4^2*swx2[2]+abc5^2*(swx3[1]+swx3[3])+abc6^2*swx3[2]
aa5<-s0[2]+abc1*n0[1]+abc2*n0[2]+abc3*n0[3]+abc4*n0[4]+abc5*(n0[5]+n0[7])+abc6*n0[6]
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma+sigma50+aa1;sigma2[2]<-sigma+sigma50
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*12
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,-1,0,0,0,0,1,0,0,1,0,
0,0,0,1,0,0,0,0.5,0,0,0,0,1,0,0,0.5,0,0,0,0,1,0,-1,0,0,0,0,0,0,1,1,0,
0,0,0,0,0,1,0,0.5,0,0,0,0,0,1,-1,0),10,8,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean2[1],mean2[2],mean3[1],mean3[2],mean3[3]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[2]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX1-AD-ADI",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B[1],4),round(B[2],4),round(B[3],4),round(B[4],4),round(B[5],4),round(B[6],4),round(B[7],4)," ",round(B[8],4)," "," "," "," "," "," "," ",
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[14]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+a1,mean[4]))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5],mean[5]-a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+a3,mean[6],mean[6]-a3))
b1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
b2<-(3*mean[1]+2*mean[2]+3*mean[3]-24.5*mean1[1]+30*mean1[2]+30*
mean2[1]-24.5*mean2[2]-24.5*mean3[1]+30*mean3[2]-24.5*mean3[3])/47
b3<-(0.5*b1^2+0.25*b2^2)/n_fam
sigma1[1]<-sigmaB1/2;sigma1[2]<-sigma1[1]+b3
sigma2[2]<-sigmaB2/2;sigma2[1]<-sigma2[2]+b3
sigma3[1]<-sigmaF2/2;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+b3
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
n0<-matrix(0,9,1);s0<-matrix(0,9,1)
hh<-matrix(0,5,5);b_line<-matrix(0,5,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1
n0[3]<-mix_pi2[1]*n_samB2;n0[4]<-mix_pi2[2]*n_samB2
n0[5]<-mix_pi3[1]*n_samF2;n0[6]<-mix_pi3[2]*n_samF2
n0[7]<-mix_pi3[3]*n_samF2
n0[c(1:7)][abs(n0[c(1:7)])<0.000001]<-0.000001
AA<-matrix(0,5,1);aaa0<-0;n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa2<-(3.0*mean[1]+2*mean[2]+3*mean[3]-24.5*mean1[1]+30*mean1[2]
+30*mean2[1]-24.5*mean2[2]-24.5*mean3[1]+30*mean3[2]-24.5*mean3[3])/47
aa1<-(0.5*aa1*aa1+0.25*aa2*aa2)/n_fam
sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma2[2]+aa1
sigma3[2]<-sigma3[1]+aa1
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma3[1]/n0[5]+16*sigma3[2]/n0[6]+4*sigma3[3]/n0[7]
hh[1,2]<-3*sigma*(1/n_samP1-1/n_samP2)
hh[1,3]<-sigma3[1]*(2/n0[5]-2/n0[7])
hh[1,4]<-sigma3[1]*(2/n0[5]+2/n0[7])
hh[1,5]<-8*sigma3[2]/n0[6]
hh[2,2]<-sigma*(1.0/n_samP1+1.0/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]
hh[2,3]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]-sigma2[2]/n0[4]
hh[2,4]<--sigma1[1]/n0[1]+sigma2[2]/n0[4]
hh[2,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[3,3]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[3,4]<-sigma1[1]/n0[1]-sigma2[2]/n0[4]+sigma3[1]/n0[4]-sigma3[3]/n0[7]
hh[3,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[4,4]<-sigma1[1]/n0[1]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[4,5]<-0
hh[5,5]<-sigma1[2]/n0[2]+sigma2[1]/n0[3]+4*sigma3[2]/n0[6]
for(i in 2:5)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-2*sumwx3[1]/n0[5]-4*sumwx3[2]/n0[6]-2*sumwx3[3]/n0[7]
b_line[2]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]+sumwx2[2]/n0[4]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-sumwx2[2]/n0[4]-sumwx3[1]/n0[5]+sumwx3[3]/n0[7]
b_line[4]<-sumwx1[1]/n0[1]+sumwx2[2]/n0[4]-sumwx3[1]/n0[5]-sumwx3[3]/n0[7]
b_line[5]<-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-2*sumwx3[2]/n0[6]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(3*B[1]+B[2]))/n_samP1
mean[2]<-(sumx[2]-2*sigma*B[1])/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[2]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(B[2]-B[3]-B[4]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[2]+B[3]-B[5]))/n0[2]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B[2]+B[3]+B[5]))/n0[3]
mean2[2]<-(sumwx2[2]+(-B[2]+B[3]-B[4])*sigma2[2])/n0[4]
mean3[1]<-(sumwx3[1]+sigma3[1]*(2*B[1]+B[3]+B[4]))/n0[5]
mean3[2]<-(sumwx3[2]+sigma3[2]*(4*B[1]+2*B[5]))/n0[6]
mean3[3]<-(sumwx3[3]+sigma3[3]*(2*B[1]-B[3]+B[4]))/n0[7]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa2<-(3.0*mean[1]+2*mean[2]+3*mean[3]-24.5*mean1[1]+30*mean1[2]+30*mean2[1]-24.5*mean2[2]-24.5*mean3[1]+30*mean3[2]-24.5*mean3[3])/47
aa1<-(0.5*aa1^2+0.25*aa2^2)/n_fam
aaa0<-sigma1[1];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab2<-sigma1[1]/(sigma1[1]+aa1)
sigma1[1]<-(swx1[1]+ab2^2*swx1[2])/(n0[1]+ab2*n0[2])
aa3<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+aa1
n0[8]<-mix_pi2[1]*n_samB2;n0[9]<-mix_pi2[2]*n_samB2
aaa0<-sigma2[2];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab3<-sigma2[2]/(sigma2[2]+aa1)
sigma2[2]<-(ab3^2*swx2[1]+swx2[2])/(ab3*n0[8]+n0[9])
aa3<-abs(sigma2[2]-aaa0)
aaa0<-sigma2[2]
if (n_iter>20) break
}
sigma50<-sigma2[2]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[2]<-sigma}
sigma2[2]<-sigma50+sigma;sigma2[1]<-sigma2[2]+aa1
n0[8]<-(mix_pi3[3]+mix_pi3[1])*n_samF2;n0[9]<-mix_pi3[2]*n_samF2
aaa0<-sigma3[1];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab4<-sigma3[1]/(sigma3[1]+aa1)
sigma3[1]<-(swx3[1]+ab4^2*swx3[2]+swx3[3])/(n0[8]+ab4*n0[9])
aa3<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+aa1
sigma3[3]<-sigma3[1]
s0[1]<-ss1+ss2+ss3;s0[2]<-n_samP1+n_samF1+n_samP2
aaa0<-0;n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
abc1<-sigma/(sigma+sigma40)
abc2<-sigma/(sigma+sigma40+aa1)
abc3<-sigma/(sigma+sigma50+aa1)
abc4<-sigma/(sigma+sigma50)
abc5<-sigma/(sigma+sigma60)
abc6<-sigma/(sigma+sigma60+aa1)
aa4<-s0[1]+abc1^2*swx1[1]+abc2^2*swx1[2]+abc3^2*swx2[1]+abc4^2*swx2[2]+abc5^2*(swx3[1]+swx3[3])+abc6^2*swx3[2]
aa5<-s0[2]+abc1*n0[1]+abc2*n0[2]+abc3*n0[3]+abc4*n0[4]+abc5*(n0[5]+n0[7])+abc6*n0[6]
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma+sigma50+aa1;sigma2[2]<-sigma+sigma50
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*9
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,0,1,0,1,0,1,0,1,1,-1,0,-1,0,1,1,0,0.5,0.25,
1,0,0.5,0.5,0.25,1,0,0.5,-0.5,0.25,1,-1,0,-0.5,0.25,
1,1,0,0,0.25,1,0,0.5,0,0.25,1,-1,0,0,0.25),10,5,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean2[1],mean2[2],mean3[1],mean3[2],mean3[3]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[2]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX1-AD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4)," ",round(B1[3],4)," "," "," "," "," ",round(B1[4],4),round(B1[5],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[15]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0
a1<-sqrt(sigmaB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+a1,mean[4]))
a2<-sqrt(sigmaB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5],mean[5]-a2))
a3<-sqrt(sigmaF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+a3,mean[6],mean[6]-a3))
b1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
b3<-(0.5*b1^2)/n_fam
sigma1[1]<-sigmaB1/2;sigma1[2]<-sigma1[1]+b3
sigma2[2]<-sigmaB2/2;sigma2[1]<-sigma2[2]+b3
sigma3[1]<-sigmaF2/2;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+b3
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
hh<-matrix(0,6,6);b_line<-matrix(0,6,1)
n0<-matrix(0,9,1);s0<-matrix(0,2,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1
n0[3]<-mix_pi2[1]*n_samB2;n0[4]<-mix_pi2[2]*n_samB2
n0[5]<-mix_pi3[1]*n_samF2;n0[6]<-mix_pi3[2]*n_samF2
n0[7]<-mix_pi3[3]*n_samF2
n0[c(1:7)][abs(n0[c(1:7)])<0.0001]<-0.0001
aaa0<-0
AA<-matrix(0,6,1);n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa1<-0.5*aa1^2/n_fam
sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma2[2]+aa1
sigma3[2]<-sigma3[1]+aa1
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+64*sigma3[2]/n0[6]
hh[1,2]<-3*sigma*(1/n_samP1-1/n_samP2)
hh[1,3]<-16*sigma3[2]/n0[6]
hh[1,4]<-0
hh[1,5]<-16*sigma3[2]/n0[6]
hh[1,6]<-16*sigma3[2]/n0[6]
hh[2,2]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]
hh[2,3]<--sigma1[1]/n0[1]+sigma2[2]/n0[4]
hh[2,4]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]-sigma2[2]/n0[4]
hh[2,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[2,6]<-0
hh[3,3]<-sigma1[1]/n0[1]+sigma2[2]/n0[4]+4*sigma3[2]/n0[6]
hh[3,4]<-sigma1[1]/n0[1]-sigma2[2]/n0[4]
hh[3,5]<-4*sigma3[2]/n0[6]
hh[3,6]<-4*sigma3[2]/n0[6]
hh[4,4]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[4,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[4,6]<--sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[5,5]<-sigma1[2]/n0[2]+sigma2[1]/n0[3]+4*sigma3[2]/n0[6]
hh[5,6]<-4*sigma3[2]/n0[6]
hh[6,6]<-sigma3[1]/n0[5]+sigma3[3]/n0[7]+4*sigma3[2]/n0[6]
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-8*sumwx3[2]/n0[6]
b_line[2]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]+sumwx2[2]/n0[4]
b_line[3]<-sumwx1[1]/n0[1]+sumwx2[2]/n0[4]-2*sumwx3[2]/n0[6]
b_line[4]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-sumwx2[2]/n0[4]-sumwx3[1]/n0[5]+sumwx3[3]/n0[7]
b_line[5]<-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-2*sumwx3[2]/n0[6]
b_line[6]<-sumwx3[1]/n0[5]+sumwx3[3]/n0[7]-2*sumwx3[2]/n0[6]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(3*B[1]+B[2]))/n_samP1
mean[2]<-(sumx[2]-2*sigma*B[1])/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[2]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(B[2]-B[3]-B[4]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[2]+B[4]-B[5]))/n0[2]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B[2]+B[4]+B[5]))/n0[3]
mean2[2]<-(sumwx2[2]+(-B[2]-B[3]+B[4])*sigma2[2])/n0[4]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[4]-B[6]))/n0[5]
mean3[2]<-(sumwx3[2]+sigma3[2]*(8*B[1]+2*B[3]+2*B[5]+2*B[6]))/n0[6]
mean3[3]<-(sumwx3[3]-sigma3[3]*(B[4]+B[6]))/n0[7]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aa1<-(mean1[1]-mean1[2]+mean2[1]-mean2[2]+2*mean3[1]-2*mean3[3])/6
aa1<-0.5*aa1*aa1/n_fam
aaa0<-sigma1[1];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab2<-sigma1[1]/(sigma1[1]+aa1)
sigma1[1]<-(swx1[1]+ab2^2*swx1[2])/(n0[1]+ab2*n0[2])
aa3<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+aa1
n0[8]<-mix_pi2[1]*n_samB2;n0[9]<-mix_pi2[2]*n_samB2
aa3<-1000;aaa0<-sigma2[2];n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab3<-sigma2[2]/(sigma2[2]+aa1)
sigma2[2]<-(ab3^2*swx2[1]+swx2[2])/(ab3*n0[8]+n0[9])
aa3<-abs(sigma2[2]-aaa0)
aaa0<-sigma2[2]
if (n_iter>20) break
}
sigma50<-sigma2[2]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[2]<-sigma}
sigma2[2]<-sigma50+sigma;sigma2[1]<-sigma2[2]+aa1
n0[8]<-(mix_pi3[3]+mix_pi3[1])*n_samF2;n0[9]<-mix_pi3[2]*n_samF2
aaa0<-sigma3[1];n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab4<-sigma3[1]/(sigma3[1]+aa1)
sigma3[1]<-(swx3[1]+ab4^2*swx3[2]+swx3[3])/(n0[8]+ab4*n0[9])
aa3<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+aa1
sigma3[3]<-sigma3[1]
s0[1]<-ss1+ss2+ss3;s0[2]<-n_samP1+n_samF1+n_samP2
aaa0<-0;n_iter<-0;aa3<-1000
while (aa3>0.0001)
{
n_iter<-n_iter+1
abc1<-sigma/(sigma+sigma40)
abc2<-sigma/(sigma+sigma40+aa1)
abc3<-sigma/(sigma+sigma50+aa1)
abc4<-sigma/(sigma+sigma50)
abc5<-sigma/(sigma+sigma60)
abc6<-sigma/(sigma+sigma60+aa1)
aa4<-s0[1]+abc1^2*swx1[1]+abc2^2*swx1[2]+abc3^2*
swx2[1]+abc4^2*swx2[2]+abc5^2*(swx3[1]+swx3[3])+abc6^2*swx3[2]
aa5<-s0[2]+abc1*n0[1]+abc2*n0[2]+abc3*n0[3]+abc4*n0[4]+abc5*(n0[5]+n0[7])+abc6*n0[6]
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma+sigma50+aa1;sigma2[2]<-sigma+sigma50
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*8
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,1,0,0,1,1,-1,-1,0,1,1,0.5,0.25,1,0,0.5,0.25,
1,0,-0.5,0.25,1,-1,-0.5,0.25,1,1,0,0.25,1,0,0,0.25,
1,-1,0,0.25),10,4,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean2[1],mean2[2],mean3[1],mean3[2],mean3[3]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[2]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX1-A-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4)," "," "," "," "," "," "," ",round(B1[3],4),round(B1[4],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[16]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+0.5*a1,0.25*(mean[1]+mean[3])+0.5*mean[2]))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5],mean[5]-2*a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean1[1],mean[6],mean2[2]))
b1<-(12*mean[1]+8*mean[2]+12*mean[3]+120*mean1[1]-98*mean1[2]+338*mean2[1]-316*mean2[2]+338*mean3[1]+120*mean3[2]-534*mean3[3])/1496
b3<-0.75*b1^2/n_fam
sigma1[1]<-sigmaB1/2;sigma1[2]<-sigma1[1]+2*b3
sigma2[2]<-sigmaB2/2;sigma2[1]<-sigma2[2]+2*b3
sigma3[1]<-sigmaF2/2;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+2*b3
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
hh<-matrix(0,6,6);b_line<-matrix(0,6,1)
n0<-matrix(0,9,1);s0<-matrix(0,2,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1
n0[3]<-mix_pi2[1]*n_samB2;n0[4]<-mix_pi2[2]*n_samB2
n0[5]<-mix_pi3[1]*n_samF2;n0[6]<-mix_pi3[2]*n_samF2
n0[7]<-mix_pi3[3]*n_samF2
n0[c(1:7)][abs(n0[c(1:7)])<0.00000001]<-0.000001
aaa0<-0 ;AA<-matrix(0,6,1);aaa1<-1000;n_iter<-0
while(aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(12*mean[1]+8*mean[2]+12*mean[3]+120*mean1[1]-98*mean1[2]+
338*mean2[1]-316*mean2[2]+338*mean3[1]+120*mean3[2]-534*mean3[3])/1496
aa1<-0.75*aa1^2/n_fam
sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma2[2]+aa1
sigma3[2]<-sigma3[1]+aa1
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma3[1]/n0[5]+16*sigma3[2]/n0[6]+4*sigma3[3]/n0[7]
hh[1,2]<-sigma*(3/n_samP1-3/n_samP2)
hh[1,3]<-sigma3[1]*(2/n0[5]-2/n0[7])
hh[1,4]<-sigma3[1]*(2/n0[5]+2/n0[7])
hh[1,5]<-8*sigma3[2]/n0[6]
hh[1,6]<-6*sigma3[1]/n0[5]-16*sigma3[2]/n0[6]+2*sigma3[3]/n0[7]
hh[2,2]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]
hh[2,3]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]-sigma2[2]/n0[4]
hh[2,4]<--sigma1[1]/n0[1]+sigma2[2]/n0[4]
hh[2,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[2,6]<-0
hh[3,3]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[3,4]<-sigma1[1]/n0[1]-sigma2[2]/n0[4]+sigma3[1]/n0[5]-sigma3[3]/n0[7]
hh[3,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[3,6]<-sigma3[1]*(3/n0[5]-1/n0[7])
hh[4,4]<-sigma1[1]/n0[1]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[4,5]<-0
hh[4,6]<-3*sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[5,5]<-sigma1[2]/n0[2]+sigma2[1]/n0[3]+4*sigma3[2]/n0[6]
hh[5,6]<--8*sigma3[2]/n0[6]
hh[6,6]<-9*sigma3[1]/n0[5]+sigma3[3]/n0[7]+16*sigma3[2]/n0[6]
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-2*sumwx3[1]/n0[5]-4*sumwx3[2]/n0[6]-2*sumwx3[3]/n0[7]
b_line[2]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]+sumwx2[2]/n0[4]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-sumwx2[2]/n0[4]-sumwx3[1]/n0[5]+sumwx3[3]/n0[7]
b_line[4]<-sumwx1[1]/n0[1]+sumwx2[2]/n0[4]-sumwx3[1]/n0[5]-sumwx3[3]/n0[7]
b_line[5]<-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-2*sumwx3[2]/n0[6]
b_line[6]<-4*sumwx3[2]/n0[6]-3*sumwx3[1]/n0[5]-sumwx3[3]/n0[7]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(3*B[1]+B[2]))/n_samP1
mean[2]<-(sumx[2]-2*sigma*B[1])/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[2]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(B[2]-B[3]-B[4]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[2]+B[3]-B[5]))/n0[2]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B[2]+B[3]+B[5]))/n0[3]
mean2[2]<-(sumwx2[2]+(-B[2]+B[3]-B[4])*sigma2[2])/n0[4]
mean3[1]<-(sumwx3[1]+sigma3[1]*(2*B[1]+B[3]+B[4]+3*B[6]))/n0[5]
mean3[2]<-(sumwx3[2]+sigma3[2]*(4*B[1]+2*B[5]-4*B[6]))/n0[6]
mean3[3]<-(sumwx3[3]+sigma3[1]*(2*B[1]-B[3]+B[4]+B[6]))/n0[7]
aaa1<-max(abs(B-AA))
AA<-B
if(n_iter>20)break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aa1<-(12*mean[1]+8*mean[2]+12*mean[3]+120*mean1[1]-98*mean1[2]+
338*mean2[1]-316*mean2[2]+338*mean3[1]+120*mean3[2]-534*mean3[3])/1496
aa1<-0.75*aa1^2/n_fam
aaa0<-sigma1[1];aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab2<-sigma1[1]/(sigma1[1]+aa1)
sigma1[1]<-(swx1[1]+ab2^2*swx1[2])/(n0[1]+ab2*n0[2])
aa3<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if(n_iter>20)break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+aa1
n0[8]<-mix_pi2[1]*n_samB2;n0[9]<-mix_pi2[2]*n_samB2
aaa0<-sigma2[2]
aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab3<-sigma2[2]/(sigma2[2]+aa1)
sigma2[2]<-(ab3*ab3*swx2[1]+swx2[2])/(ab3*n0[8]+n0[9])
aa3<-abs(sigma2[2]-aaa0)
aaa0<-sigma2[2]
if(n_iter>20)break
}
sigma50<-sigma2[2]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[2]<-sigma}
sigma2[2]<-sigma50+sigma;sigma2[1]<-sigma2[2]+aa1
n0[8]<-(mix_pi3[3]+mix_pi3[1])*n_samF2;n0[9]<-mix_pi3[2]*n_samF2
aaa0<-sigma3[1];aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab4<-sigma3[1]/(sigma3[1]+aa1)
sigma3[1]<-(swx3[1]+ab4^2*swx3[2]+swx3[3])/(n0[8]+ab4*n0[9])
aa3<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if(n_iter>20)break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+aa1
sigma3[3]<-sigma3[1]
s0[1]<-ss1+ss2+ss3;s0[2]<-n_samP1+n_samF1+n_samP2
aaa0<-0;aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
abc1<-sigma/(sigma+sigma40)
abc2<-sigma/(sigma+sigma40+aa1)
abc3<-sigma/(sigma+sigma50+aa1)
abc4<-sigma/(sigma+sigma50)
abc5<-sigma/(sigma+sigma60)
abc6<-sigma/(sigma+sigma60+aa1)
aa4<-s0[1]+abc1^2*swx1[1]+abc2^2*swx1[2]+abc3^2*swx2[1]+abc4^2*swx2[2]+abc5^2*(swx3[1]+swx3[3])+abc6^2*swx3[2]
aa5<-s0[2]+abc1*n0[1]+abc2*n0[2]+abc3*n0[3]+abc4*n0[4]+abc5*(n0[5]+n0[7])+abc6*n0[6]
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma+sigma50+aa1;sigma2[2]<-sigma+sigma50
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*8
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,1,1,0,1,1,-1,-1,0,1,1,0.5,0.25,1,0.5,0.5,0.25,
1,0.5,-0.5,0.25,1,-1,-0.5,0.25,1,1,0,0.25,1,0.5,0,0.25,
1,-1,0,0.25),10,4,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean2[1],mean2[2],mean3[1],mean3[2],mean3[3]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[2]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX1-EAD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4)," ",round(B1[2],4)," "," "," "," "," ",round(B1[3],4),round(B1[4],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[17]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.5,2,1);sigma1<-matrix(0,2,1)
mi2<-matrix(0.5,2,1);sigma2<-matrix(0,2,1)
mi3<-as.matrix(c(0.25,0.5,0.25));sigma3<-matrix(0,3,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+0.5*a1,0.25*(mean[1]+mean[3])+0.5*mean[2]))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5],mean[5]-2*a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean1[1],mean[6],mean2[2]))
b1<-(-12*mean[1]-8*mean[2]-12*mean[3]+316*mean1[1]-338*mean1[2]+98*mean2[1]-120*mean2[2]+534*mean3[1]-120*mean3[2]-338*mean3[3])/1496
b3<-0.75*b1^2/n_fam
sigma1[1]<-sigmaB1/2;sigma1[2]<-sigma1[1]+2*b3
sigma2[2]<-sigmaB2/2;sigma2[1]<-sigma2[2]+2*b3
sigma3[1]<-sigmaF2/2;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+2*b3
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,2,n_samB1); swx1 <- matrix(0,2,1)
W2 <- matrix(0,2,n_samB2); swx2 <- matrix(0,2,1)
W3 <- matrix(0,3,n_samF2); swx3 <- matrix(0,3,1)
hh<-matrix(0,6,6);b_line<-matrix(0,6,1)
n0<-matrix(0,9,1);s0<-matrix(0,2,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:2) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:2) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:3) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1
n0[3]<-mix_pi2[1]*n_samB2;n0[4]<-mix_pi2[2]*n_samB2
n0[5]<-mix_pi3[1]*n_samF2;n0[6]<-mix_pi3[2]*n_samF2
n0[7]<-mix_pi3[3]*n_samF2
n0[c(1:7)][abs(n0[c(1:7)])<0.00000001]<-0.000001
aaa0<-0 ;AA<-matrix(0,6,1);aaa1<-1000;n_iter<-0
while(aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-(-12*mean[1]-8*mean[2]-12*mean[3]+316*mean1[1]-338*mean1[2]+98*mean2[1]-120*mean2[2]+534*mean3[1]-120*mean3[2]-338*mean3[3])/1496
aa1<-0.75*aa1^2/n_fam
sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma2[2]+aa1
sigma3[2]<-sigma3[1]+aa1
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma3[1]/n0[5]+16*sigma3[2]/n0[6]+4*sigma3[3]/n0[7]
hh[1,2]<-sigma*(3/n_samP1-3/n_samP2)
hh[1,3]<-sigma3[1]*(2/n0[5]-2/n0[7])
hh[1,4]<-sigma3[1]*(2/n0[5]+2/n0[7])
hh[1,5]<-8*sigma3[2]/n0[6]
hh[1,6]<-2*sigma3[1]/n0[5]-16*sigma3[2]/n0[6]+6*sigma3[3]/n0[7]
hh[2,2]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]
hh[2,3]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]-sigma2[2]/n0[4]
hh[2,4]<--sigma1[1]/n0[1]+sigma2[2]/n0[4]
hh[2,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[2,6]<-0
hh[3,3]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma2[1]/n0[3]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[3,4]<-sigma1[1]/n0[1]-sigma2[2]/n0[4]+sigma3[1]/n0[5]-sigma3[3]/n0[7]
hh[3,5]<--sigma1[2]/n0[2]+sigma2[1]/n0[3]
hh[3,6]<-sigma3[1]*(1/n0[5]-3/n0[7])
hh[4,4]<-sigma1[1]/n0[1]+sigma2[2]/n0[4]+sigma3[1]/n0[5]+sigma3[3]/n0[7]
hh[4,5]<-0
hh[4,6]<-sigma3[1]/n0[5]+3*sigma3[3]/n0[7]
hh[5,5]<-sigma1[2]/n0[2]+sigma2[1]/n0[3]+4*sigma3[2]/n0[6]
hh[5,6]<--8*sigma3[2]/n0[6]
hh[6,6]<-sigma3[1]/n0[5]+16*sigma3[2]/n0[6]+9*sigma3[3]/n0[7]
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-2*sumwx3[1]/n0[5]-4*sumwx3[2]/n0[6]-2*sumwx3[3]/n0[7]
b_line[2]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]+sumwx2[2]/n0[4]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-sumwx2[2]/n0[4]-sumwx3[1]/n0[5]+sumwx3[3]/n0[7]
b_line[4]<-sumwx1[1]/n0[1]+sumwx2[2]/n0[4]-sumwx3[1]/n0[5]-sumwx3[3]/n0[7]
b_line[5]<-sumwx1[2]/n0[2]+sumwx2[1]/n0[3]-2*sumwx3[2]/n0[6]
b_line[6]<-4*sumwx3[2]/n0[6]-sumwx3[1]/n0[5]-3*sumwx3[3]/n0[7]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(3*B[1]+B[2]))/n_samP1
mean[2]<-(sumx[2]-2*sigma*B[1])/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[2]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(B[2]-B[3]-B[4]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[2]+B[3]-B[5]))/n0[2]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B[2]+B[3]+B[5]))/n0[3]
mean2[2]<-(sumwx2[2]+(-B[2]+B[3]-B[4])*sigma2[2])/n0[4]
mean3[1]<-(sumwx3[1]+sigma3[1]*(2*B[1]+B[3]+B[4]+B[6]))/n0[5]
mean3[2]<-(sumwx3[2]+sigma3[2]*(4*B[1]+2*B[5]-4*B[6]))/n0[6]
mean3[3]<-(sumwx3[3]+sigma3[3]*(2*B[1]-B[3]+B[4]+3*B[6]))/n0[7]
aaa1<-max(abs(B-AA))
AA<-B
if(n_iter>20)break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:2) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:2) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:3) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aa1<-(-12*mean[1]-8*mean[2]-12*mean[3]+316*mean1[1]-338*mean1[2]+98*mean2[1]-120*mean2[2]+534*mean3[1]-120*mean3[2]-338*mean3[3])/1496
aa1<-0.75*aa1^2/n_fam
aaa0<-sigma1[1];aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab2<-sigma1[1]/(sigma1[1]+aa1)
sigma1[1]<-(swx1[1]+ab2^2*swx1[2])/(n0[1]+ab2*n0[2])
aa3<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if(n_iter>20)break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+aa1
n0[8]<-mix_pi2[1]*n_samB2;n0[9]<-mix_pi2[2]*n_samB2
aaa0<-sigma2[2];aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab3<-sigma2[2]/(sigma2[2]+aa1)
sigma2[2]<-(ab3^2*swx2[1]+swx2[2])/(ab3*n0[8]+n0[9])
aa3<-abs(sigma2[2]-aaa0)
aaa0<-sigma2[2]
if(n_iter>20)break
}
sigma50<-sigma2[2]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[2]<-sigma}
sigma2[2]<-sigma50+sigma;sigma2[1]<-sigma2[2]+aa1
n0[8]<-(mix_pi3[3]+mix_pi3[1])*n_samF2;n0[9]<-mix_pi3[2]*n_samF2
aaa0<-sigma3[1];aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
ab4<-sigma3[1]/(sigma3[1]+aa1)
sigma3[1]<-(swx3[1]+ab4^2*swx3[2]+swx3[3])/(n0[8]+ab4*n0[9])
aa3<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if(n_iter>20)break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+aa1;sigma3[3]<-sigma3[1]
s0[1]<-ss1+ss2+ss3;s0[2]<-n_samP1+n_samF1+n_samP2
aaa0<-0;aa3<-1000;n_iter<-0
while (aa3>0.0001)
{
n_iter<-n_iter+1
abc1<-sigma/(sigma+sigma40)
abc2<-sigma/(sigma+sigma40+aa1)
abc3<-sigma/(sigma+sigma50+aa1)
abc4<-sigma/(sigma+sigma50)
abc5<-sigma/(sigma+sigma60)
abc6<-sigma/(sigma+sigma60+aa1)
aa4<-s0[1]+abc1^2*swx1[1]+abc2^2*swx1[2]+abc3^2*swx2[1]+abc4^2*swx2[2]+abc5^2*(swx3[1]+swx3[3])+abc6^2*swx3[2]
aa5<-s0[2]+abc1*n0[1]+abc2*n0[2]+abc3*n0[3]+abc4*n0[4]+abc5*(n0[5]+n0[7])+abc6*n0[6]
sigma<-aa4/aa5
aa3<-abs(sigma-aaa0)
aaa0<-sigma
if(n_iter>20)break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+aa1
sigma2[1]<-sigma+sigma50+aa1;sigma2[2]<-sigma+sigma50
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[1];sigma3[2]<-sigma3[1]+aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*8
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,2)
for(i in 1:2){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,2)
for(i in 1:2){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,3)
for(i in 1:3){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,1,-1,0,1,1,-1,-1,0,1,1,0.5,0.25,1,-0.5,0.5,0.25,
1,-0.5,-0.5,0.25,1,-1,-0.5,0.25,1,1,0,0.25,1,-0.5,0,0.25,
1,-1,0,0.25),10,4,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean2[1],mean2[2],mean3[1],mean3[2],mean3[3]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[2]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[2]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX1-NCD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," "," ",round(t(sigma1),4)," "," ",
round(t(mix_pi1),4)," "," ",round(t(mean2),4)," "," ",round(t(sigma2),4)," "," ",round(t(mix_pi2),4)," "," ",
round(t(mean3),4)," "," "," "," "," "," ",round(t(sigma3),4)," "," "," "," "," "," ",round(t(mix_pi3),4)," "," "," "," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4)," ",round(-B1[2],4)," "," "," "," "," ",round(B1[3],4),round(B1[4],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[18]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigma40/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2*a1,mean[4]+a1,mean[4]-a1,mean[4]-2*a1))
a2<-sqrt(sigma50/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5]+a2,mean[5]-a2,mean[5]-2*a2))
a3<-sqrt(sigma60/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+2.8*a3,mean[6]+2.1*a3,mean[6]+1.4*a3,mean[6]+0.7*a3,mean[6],mean[6]-0.7*a3,mean[6]-1.4*a3,mean[6]-2.1*a3,mean[6]-2.8*a3))
sigma1[1]<-sigmaB1/2;sigma2[4]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
aa<-matrix(c(1,0,0,0,0,0,1,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,1,0,0,1,0,0,0,-1,-1,0,0,
1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0.5,0,0.5,0,0,0,0,0,1,0,0,
0,1,0.5,0,0,0,0.5,0,0,0,0,1,0,0,0,0,0.5,0.5,0,0,0,0.25,0,0,0,0,1,0,0,0,0.5,0.5,0,
0,0,0.25,0,0,0,0,1,0,0,-1,0.5,0,0,0,-0.5,0,0,0,0,0,1,0,-1,0,0,0.5,0,-0.5,0,0,0,0,0,
0,1,0,-1,-1,0,0,1,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0.5,0,0.5,0,0,
0,0,0,0,0,1,1,-1,0,0,-1,0,0,0,0,0,0,0,0,1,0,1,0.5,0,0,0,0.5,0,0,0,0,0,0,1,0,0,0.5,0.5,
0,0,0,0.25,0,0,0,0,0,1,0,-1,0.5,0,0,0,-0.5,0,0,0,0,0,0,1,-1,1,0,0,-1,0,0,0,0,0,0,0,0,1,
-1,0,0,0.5,0,-0.5,0,0,0,0,0,0,0,1,-1,-1,0,0,1,0,0,0),20,14,byrow=T)
mm<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B<-solve(crossprod(aa,aa))%*%crossprod(aa,mm)
gs<-matrix(0,8,1)
gs[1]<-B[7];gs[2]<-B[8];gs[3]<-B[9];gs[4]<-B[10];gs[5]<-B[11];gs[6]<-B[12];gs[7]<-B[13];gs[8]<-B[14]
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
sigma2[1]<-sigma2[4]+g_aa5;sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[1];sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa5;sigma3[6]<-sigma3[1]+g_aa3;sigma3[7]<-sigma3[1]
sigma3[8]<-sigma3[1]+g_aa4;sigma3[9]<-sigma3[1]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
hh<-matrix(0,6,6); b_line1<-matrix(0,20,1);b_line2<-matrix(0,6,1)
n0<-matrix(0,18,1);s0<-matrix(0,18,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[1]<-mix_pi1[1]*n_samB1;n0[2]<-mix_pi1[2]*n_samB1;n0[3]<-mix_pi1[3]*n_samB1
n0[4]<-mix_pi1[4]*n_samB1;n0[5]<-mix_pi2[1]*n_samB2;n0[6]<-mix_pi2[2]*n_samB2
n0[7]<-mix_pi2[3]*n_samB2;n0[8]<-mix_pi2[4]*n_samB2
s0[1]<-mix_pi3[1]*n_samF2;s0[2]<-mix_pi3[2]*n_samF2;s0[3]<-mix_pi3[3]*n_samF2
s0[4]<-mix_pi3[4]*n_samF2;s0[5]<-mix_pi3[5]*n_samF2;s0[6]<-mix_pi3[6]*n_samF2
s0[7]<-mix_pi3[7]*n_samF2;s0[8]<-mix_pi3[8]*n_samF2;s0[9]<-mix_pi3[9]*n_samF2
s0[c(1:9)][abs(s0[c(1:9)])<0.00000001]<-0.000001
n0[c(1:8)][abs(n0[c(1:8)])<0.00000001]<-0.000001
n_iter<-0;aaa1<-1000;AA<-matrix(0,6,1)
while(aaa1>0.0001)
{
n_iter<-n_iter+1
aa11<-aa
mm11<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B1<-solve(t(aa11)%*%aa11)%*%(t(aa11)%*%mm11)
gs[1]<-B1[7];gs[2]<-B1[8];gs[3]<-B1[9];gs[4]<-B1[10];gs[5]<-B1[11];gs[6]<-B1[12];gs[7]<-B1[13];gs[8]<-B1[14];
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
sigma2[1]<-sigma2[4]+g_aa5;sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa5;sigma3[6]<-sigma3[1]+g_aa3
sigma3[8]<-sigma3[1]+g_aa4
hh[1,1]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[1,2]<-0
hh[1,3]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[1,4]<-0
hh[1,5]<-0
hh[1,6]<-0
hh[2,2]<-sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[2,3]<-sigma1[4]/n0[4]+sigma3[5]/s0[5]
hh[2,4]<--sigma3[5]/s0[5]
hh[2,5]<-0
hh[2,6]<--sigma3[5]/s0[5]
hh[3,3]<-sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma3[1]/s0[1]+sigma3[5]/s0[5]
hh[3,4]<--sigma3[5]/s0[5]
hh[3,5]<-0
hh[3,6]<--sigma3[5]/s0[5]
hh[4,4]<-sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma3[5]/s0[5]+sigma3[6]/s0[6]
hh[4,5]<-0
hh[4,6]<-sigma2[1]/n0[5]+sigma3[5]/s0[5]
hh[5,5]<-sigma2[3]/n0[7]+sigma2[4]/n0[8]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[5,6]<-sigma2[4]/n0[8]+sigma3[9]/s0[9]
hh[6,6]<-sigma2[1]/n0[5]+sigma2[4]/n0[8]+sigma3[1]/s0[1]+sigma3[9]/s0[9]
for(i in 2:6)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line2[1]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2]
b_line2[2]<-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line2[3]<-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]-sumwx3[1]/s0[1]+sumwx3[5]/s0[5]
b_line2[4]<-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
b_line2[5]<-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]-sumwx3[8]/s0[8]+sumwx3[9]/s0[9]
b_line2[6]<-sumwx2[1]/n0[5]-sumwx2[4]/n0[8]-sumwx3[5]/s0[5]+sumwx3[9]/s0[9]
B2<-solve(hh,b_line2)
mean[1]<-sumx[1]/n_samP1;mean[2]<-sumx[2]/n_samF1;mean[3]<-sumx[3]/n_samP2
mean1[1]<-(sumwx1[1]-sigma1[1]*(B2[1]+B2[3]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*B2[1])/n0[2]
mean1[3]<-(sumwx1[3]-sigma1[3]*B2[2])/n0[3]
mean1[4]<-(sumwx1[4]+sigma1[4]*(B2[2]+B2[3]))/n0[4]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B2[4]+B2[6]))/n0[5]
mean2[2]<-(sumwx2[2]+sigma2[2]*B2[4])/n0[6]
mean2[3]<-(sumwx2[3]-sigma2[3]*B2[5])/n0[7]
mean2[4]<-(sumwx2[4]+sigma2[4]*(B2[5]+B2[6]))/n0[8]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B2[1]+B2[3]))/s0[1]
mean3[2]<-(sumwx3[2]-sigma3[2]*B2[1])/s0[2]
mean3[3]<-sumwx3[3]/s0[3]
mean3[7]<-sumwx3[7]/s0[7]
mean3[4]<-(sumwx3[4]+sigma3[4]*B2[2])/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-B2[2]-B2[3]+B2[4]+B2[6]))/s0[5]
mean3[6]<-(sumwx3[6]-sigma3[6]*B2[4])/s0[6]
mean3[8]<-(sumwx3[8]+sigma3[8]*B2[5])/s0[8]
mean3[9]<-(sumwx3[9]-sigma3[9]*(B2[5]+B2[6]))/s0[9]
aaa1<-max(abs(B2-AA))
AA<-B2
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
aa4<-sigma1[1]/(sigma1[1]+g_aa5)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2+swx1[4]*aa4^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]+aa4*n0[4]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
aaa0<-sigma2[4];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma2[4]/(sigma2[4]+g_aa5)
aa2<-sigma2[4]/(sigma2[4]+g_aa3)
aa3<-sigma2[4]/(sigma2[4]+g_aa4)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]*aa3^2+swx2[4]
as4<-aa1*n0[5]+aa2*n0[6]+aa3*n0[7]+n0[8]
sigma2[4]<-as3/as4
aaa1<-abs(sigma2[4]-aaa0)
aaa0<-sigma2[4]
if (n_iter>20) break
}
sigma50<-sigma2[4]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[4]<-sigma}
sigma2[4]<-sigma50+sigma;sigma2[1]<-sigma2[4]+g_aa5
sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[7]+swx3[9]
aa7<-s0[1]+s0[3]+s0[7]+s0[9]
n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
aa3<-sigma3[1]/(sigma3[1]+g_aa3)
aa4<-sigma3[1]/(sigma3[1]+g_aa4)
aa5<-sigma3[1]/(sigma3[1]+g_aa5)
as5<-aa6+swx3[2]*aa1^2+swx3[4]*aa2^2+swx3[5]*aa5^2+swx3[6]*aa3^2+swx3[8]*aa4^2
as6<-aa7+aa1*s0[2]+aa2*s0[4]+aa5*s0[5]+aa3*s0[6]+aa4*s0[8]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa5
sigma3[6]<-sigma3[1]+g_aa3;sigma3[8]<-sigma3[1]+g_aa4
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
n0[14]<-sigma/(sigma+sigma40+g_aa5)
s0[11]<-sigma/(sigma+sigma50+g_aa5)
s0[12]<-sigma/(sigma+sigma50+g_aa3)
s0[13]<-sigma/(sigma+sigma50+g_aa4)
s0[14]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:4)]*n0[c(11:14)]^2+swx2[c(1:4)]*s0[c(11:14)]^2)
ab4<-sum(n0[c(1:4)]*n0[c(11:14)]+n0[c(5:8)]*s0[c(11:14)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[17]<-n0[19]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1);n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-sigma/(sigma+sigma60+g_aa5);n0[16]<-sigma/(sigma+sigma60+g_aa3)
n0[18]<-sigma/(sigma+sigma60+g_aa4)
ab3<-ab3+sum(swx3[c(1:9)]*n0[c(11:19)]^2)
ab4<-ab4+sum(s0[c(1:9)]*n0[11:19])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
sigma2[4]<-sigma+sigma50;sigma2[1]<-sigma2[4]+g_aa5
sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
sigma3[1]<-sigma+sigma60
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[2]<-sigma3[1]+g_aa1;sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa5;sigma3[6]<-sigma3[1]+g_aa3
sigma3[8]<-sigma3[1]+g_aa4
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*18
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa3<-aa
b_line3<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B3<-solve(crossprod(aa3,aa3))%*%crossprod(aa3,b_line3)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[4]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-ADI-ADI",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B3[1],4),round(B3[2],4),round(B3[3],4),round(B3[4],4),round(B3[5],4),round(B3[6],4),round(B3[7],4),round(B3[8],4),round(B3[9],4),round(B3[10],4),round(B3[11],4),round(B3[12],4),round(B3[13],4),round(B3[14],4)," "," ",
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[19]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigma40/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[4]+2.5*a1,mean[4]+0.5*a1,mean[4]-0.5*a1,mean[4]-2.5*a1))
a2<-sqrt(sigma50/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2.5*a2,mean[5]+0.5*a2,mean[5]-0.5*a2,mean[5]-2.5*a2))
a3<-sqrt(sigma60/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-as.matrix(c(mean[6]+3*a3,mean[6]+2.1*a3,mean[6]+1.4*a3,mean[6]+0.7*a3,mean[6],mean[6]-0.7*a3,mean[6]-1.4*a3,mean[6]-2.1*a3,mean[6]-3*a3))
sigma1[1]<-sigmaB1/2;sigma2[4]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,8,1)
gs[1]<-0.01844*mean[1]-0.0013*mean[2]-0.02236*mean[3]+0.08161*mean1[1]-
0.02293*mean1[2]-0.03212*mean1[3]-0.06119*mean1[4]+0.06467*mean2[1]+
0.03081*mean2[2]+0.03655*mean2[3]-0.08506*mean2[4]+0.14454*mean3[1]+
0.03309*mean3[2]+0.24459*mean3[3]+0.03081*mean3[4]+0.00174*mean3[5]-
0.03212*mean3[6]-0.25541*mean3[7]-0.02639*mean3[8]-0.14799*mean3[9]
gs[2]<-0.01844*mean[1]-0.0013*mean[2]-0.02236*mean[3]+0.08161*mean1[1]-
0.02293*mean1[2]-0.03212*mean1[3]-0.06119*mean1[4]+0.06467*mean2[1]+
0.03081*mean2[2]+0.03655*mean2[3]-0.08506*mean2[4]+0.14454*mean3[1]+
0.03309*mean3[2]-0.25541*mean3[3]+0.03081*mean3[4]+0.00174*mean3[5]-
0.03212*mean3[6]+0.24459*mean3[7]-0.02639*mean3[8]-0.14799*mean3[9]
gs[3]<--0.19992*mean[1]-0.12552*mean[2]-0.17662*mean[3]-0.13771*mean1[1]+
0.0197*mean1[2]+0.43142*mean1[3]+0.1557*mean1[4]+0.179*mean2[1]+
0.44307*mean2[2]-0.06186*mean2[3]-0.13771*mean2[4]-0.12606*mean3[1]-
0.15507*mean3[2]-0.4637*mean3[3]+0.44307*mean3[4]+0.16735*mean3[5]+
0.43142*mean3[6]-0.4637*mean3[7]-0.07351*mean3[8]-0.14936*mean3[9]
gs[4]<--0.15292*mean[1]-0.08351*mean[2]-0.09759*mean[3]-0.11036*mean1[1]+
0.53258*mean1[2]-0.05558*mean1[3]+0.08368*mean1[4]+0.139*mean2[1]-
0.02792*mean2[2]+0.33893*mean2[3]-0.11036*mean2[4]-0.0827*mean3[1]+
0.11763*mean3[2]-0.34598*mean3[3]-0.02792*mean3[4]+0.11134*mean3[5]-
0.05558*mean3[6]-0.34598*mean3[7]+0.31127*mean3[8]-0.13802*mean3[9]
gs[5]<-0.03146*mean[1]+0.02343*mean[2]+0.03883*mean[3]+0.10843*mean1[1]+
0.03146*mean1[2]+0.00987*mean1[3]-0.03492*mean1[4]-0.02756*mean2[1]+
0.01356*mean2[2]+0.00569*mean2[3]+0.10843*mean2[4]+0.11211*mean3[1]-
0.02376*mean3[2]-0.24799*mean3[3]+0.01356*mean3[4]-0.03124*mean3[5]+
0.00987*mean3[6]-0.24799*mean3[7]+0.00201*mean3[8]+0.10475*mean3[9]
gs[6]<--0.12844*mean[1]+0.02088*mean[2]+0.19107*mean[3]-0.13908*mean1[1]+
0.36686*mean1[2]+0.0139*mean1[3]-0.02092*mean1[4]-0.03475*mean2[1]+
0.00698*mean2[2]-0.58473*mean2[3]+0.19426*mean2[4]-0.14599*mean3[1]+
0.47059*mean3[2]-0.41351*mean3[3]+0.00698*mean3[4]-0.02784*mean3[5]+
0.0139*mean3[6]+0.58649*mean3[7]-0.57782*mean3[8]+0.20117*mean3[9]
gs[7]<-(-mean[1]+mean[3]-mean1[1]+3*mean1[3]-3*mean2[2]+mean2[4]-
mean3[1]+3*mean3[3]+3*mean3[4]-3*mean3[6]-3*mean3[7]+
mean3[9])/6.0
gs[8]<-1.01848*mean[1]+0.65486*mean[2]+0.9461*mean[3]-0.1674*mean1[1]-
0.7552*mean1[2]-0.65447*mean1[3]+0.49638*mean1[4]+0.424*mean2[1]-
0.69066*mean2[2]-0.50187*mean2[3]-0.1674*mean2[4]-0.20359*mean3[1]-
0.21234*mean3[2]+0.64749*mean3[3]-0.69066*mean3[4]+0.46019*mean3[5]-
0.65447*mean3[6]+0.64749*mean3[7]-0.46567*mean3[8]-0.13121*mean3[9]
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
sigma2[1]<-sigma2[4]+g_aa5;sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa5;sigma3[6]<-sigma3[1]+g_aa3;sigma3[8]<-sigma3[1]+g_aa4
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
hh<-matrix(0,9,9);b_line<-matrix(0,9,1)
n0<-matrix(0,18,1);s0<-matrix(0,18,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:4)]<-mix_pi1[c(1:4)]*n_samB1;n0[c(5:8)]<-mix_pi2[c(1:4)]*n_samB2
s0[c(1:9)]<-mix_pi3[c(1:9)]*n_samF2
s0[c(1:9)][abs(s0[c(1:9)])<0.00000001]<-0.000001
n0[c(1:8)][abs(n0[c(1:8)])<0.00000001]<-0.000001
aaa0<-0;AA<-matrix(0,9,1);n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
gs[1]<-0.01844*mean[1]-0.0013*mean[2]-0.02236*mean[3]+0.08161*mean1[1]-
0.02293*mean1[2]-0.03212*mean1[3]-0.06119*mean1[4]+0.06467*mean2[1]+
0.03081*mean2[2]+0.03655*mean2[3]-0.08506*mean2[4]+0.14454*mean3[1]+
0.03309*mean3[2]+0.24459*mean3[3]+0.03081*mean3[4]+0.00174*mean3[5]-
0.03212*mean3[6]-0.25541*mean3[7]-0.02639*mean3[8]-0.14799*mean3[9]
gs[2]<-0.01844*mean[1]-0.0013*mean[2]-0.02236*mean[3]+0.08161*mean1[1]-
0.02293*mean1[2]-0.03212*mean1[3]-0.06119*mean1[4]+0.06467*mean2[1]+
0.03081*mean2[2]+0.03655*mean2[3]-0.08506*mean2[4]+0.14454*mean3[1]+
0.03309*mean3[2]-0.25541*mean3[3]+0.03081*mean3[4]+0.00174*mean3[5]-
0.03212*mean3[6]+0.24459*mean3[7]-0.02639*mean3[8]-0.14799*mean3[9]
gs[3]<--0.19992*mean[1]-0.12552*mean[2]-0.17662*mean[3]-0.13771*mean1[1]+
0.0197*mean1[2]+0.43142*mean1[3]+0.1557*mean1[4]+0.179*mean2[1]+
0.44307*mean2[2]-0.06186*mean2[3]-0.13771*mean2[4]-0.12606*mean3[1]-
0.15507*mean3[2]-0.4637*mean3[3]+0.44307*mean3[4]+0.16735*mean3[5]+
0.43142*mean3[6]-0.4637*mean3[7]-0.07351*mean3[8]-0.14936*mean3[9]
gs[4]<--0.15292*mean[1]-0.08351*mean[2]-0.09759*mean[3]-0.11036*mean1[1]+
0.53258*mean1[2]-0.05558*mean1[3]+0.08368*mean1[4]+0.139*mean2[1]-
0.02792*mean2[2]+0.33893*mean2[3]-0.11036*mean2[4]-0.0827*mean3[1]+
0.11763*mean3[2]-0.34598*mean3[3]-0.02792*mean3[4]+0.11134*mean3[5]-
0.05558*mean3[6]-0.34598*mean3[7]+0.31127*mean3[8]-0.13802*mean3[9]
gs[5]<-0.03146*mean[1]+0.02343*mean[2]+0.03883*mean[3]+0.10843*mean1[1]+
0.03146*mean1[2]+0.00987*mean1[3]-0.03492*mean1[4]-0.02756*mean2[1]+
0.01356*mean2[2]+0.00569*mean2[3]+0.10843*mean2[4]+0.11211*mean3[1]-
0.02376*mean3[2]-0.24799*mean3[3]+0.01356*mean3[4]-0.03124*mean3[5]+
0.00987*mean3[6]-0.24799*mean3[7]+0.00201*mean3[8]+0.10475*mean3[9]
gs[6]<--0.12844*mean[1]+0.02088*mean[2]+0.19107*mean[3]-0.13908*mean1[1]+
0.36686*mean1[2]+0.0139*mean1[3]-0.02092*mean1[4]-0.03475*mean2[1]+
0.00698*mean2[2]-0.58473*mean2[3]+0.19426*mean2[4]-0.14599*mean3[1]+
0.47059*mean3[2]-0.41351*mean3[3]+0.00698*mean3[4]-0.02784*mean3[5]+
0.0139*mean3[6]+0.58649*mean3[7]-0.57782*mean3[8]+0.20117*mean3[9]
gs[7]<-(-mean[1]+mean[3]-mean1[1]+3*mean1[3]-3*mean2[2]+mean2[4]-
mean3[1]+3*mean3[3]+3*mean3[4]-3*mean3[6]-3*mean3[7]+
mean3[9])/6
gs[8]<-1.01848*mean[1]+0.65486*mean[2]+0.9461*mean[3]-0.1674*mean1[1]-
0.7552*mean1[2]-0.65447*mean1[3]+0.49638*mean1[4]+0.424*mean2[1]-
0.69066*mean2[2]-0.50187*mean2[3]-0.1674*mean2[4]-0.20359*mean3[1]-
0.21234*mean3[2]+0.64749*mean3[3]-0.69066*mean3[4]+0.46019*mean3[5]-
0.65447*mean3[6]+0.64749*mean3[7]-0.46567*mean3[8]-0.13121*mean3[9]
g_aa1<-(0.5*(gs[2]+gs[5])^2+0.25*(gs[4]+gs[6])^2)/n_fam
g_aa2<-(0.5*(gs[1]+gs[5])^2+0.25*(gs[3]+gs[7])^2)/n_fam
g_aa3<-(0.5*(gs[1]-gs[5])^2+0.25*(gs[3]-gs[7])^2)/n_fam
g_aa4<-(0.5*(gs[2]-gs[5])^2+0.25*(gs[4]-gs[6])^2)/n_fam
g_aa5<-0.25*(gs[1]^2+gs[2]^2+gs[5]^2+(gs[1]+gs[6])^2+(gs[2]+gs[7])^2+(gs[3]+gs[8]/2)^2+(gs[4]+gs[8]/2)^2+gs[8]^2/4)/n_fam
hh[1,1]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[1,2]<-0
hh[1,3]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[1,4]<-0
hh[1,5]<-0
hh[1,6]<-0
hh[1,7]<--sigma1[1]/n0[1]
hh[1,8]<-0
hh[1,9]<-7*sigma3[1]/s0[1]+4*sigma3[2]/s0[2]
hh[2,2]<-sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[2,3]<-sigma1[4]/n0[4]+sigma3[5]/s0[5]
hh[2,4]<--sigma3[5]/s0[5]
hh[2,5]<-0
hh[2,6]<--sigma3[5]/s0[5]
hh[2,7]<-sigma1[4]/n0[4]
hh[2,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[2,9]<--4*sigma3[4]/s0[4]-16*sigma3[5]/s0[5]
hh[3,3]<-sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma3[1]/s0[1]+sigma3[5]/s0[5]
hh[3,4]<--sigma3[5]/s0[5]
hh[3,5]<-0
hh[3,6]<--sigma3[5]/s0[5]
hh[3,7]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[3,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[3,9]<-7*sigma3[1]/s0[1]-16*sigma3[5]/s0[5]
hh[4,4]<-sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma3[5]/s0[5]+sigma3[6]/s0[6]
hh[4,5]<-0
hh[4,6]<-sigma2[1]/n0[5]+sigma3[5]/s0[5]
hh[4,7]<-sigma2[1]/n0[5]
hh[4,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[4,9]<-16*sigma3[5]/s0[5]+4*sigma3[6]/s0[6]
hh[5,5]<-sigma2[3]/n0[7]+sigma2[4]/n0[8]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[5,6]<-sigma2[4]/n0[8]+sigma3[9]/s0[9]
hh[5,7]<--sigma2[4]/n0[8]
hh[5,8]<-0
hh[5,9]<--4*sigma3[8]/s0[8]-7*sigma3[9]/s0[9]
hh[6,6]<-sigma2[1]/n0[5]+sigma2[4]/n0[8]+sigma3[5]/s0[5]+sigma3[9]/s0[9]
hh[6,7]<-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[6,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[6,9]<-16*sigma3[5]/s0[5]-7*sigma3[9]/s0[9]
hh[7,7]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[7,8]<--sigma1[4]/n0[4]+sigma2[1]/n0[5]
hh[7,9]<-6*(sigma/n_samP1-sigma/n_samP2)
hh[8,8]<-sigma1[4]/n0[4]+sigma2[1]/n0[5]+4*sigma3[5]/s0[5]
hh[8,9]<-32*sigma3[5]/s0[5]
hh[9,9]<-sigma*(36/n_samP1+16/n_samF1+36/n_samP2)+49*sigma3[1]/s0[1]+16*
sigma3[2]/s0[2]+sigma3[3]/s0[3]+16*sigma3[4]/s0[4]+256*sigma3[5]/s0[5]+16*sigma3[6]/s0[6]+sigma3[7]/s0[7]+16*sigma3[8]/s0[8]+49*sigma3[9]/s0[9]
for(i in 2:9)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2]
b_line[2]<-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]-sumwx3[1]/s0[1]+sumwx3[5]/s0[5]
b_line[4]<-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
b_line[5]<-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]-sumwx3[8]/s0[8]+sumwx3[9]/s0[9]
b_line[6]<-sumwx2[1]/n0[5]-sumwx2[4]/n0[8]-sumwx3[5]/s0[5]+sumwx3[9]/s0[9]
b_line[7]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]+sumwx2[4]/n0[8]
b_line[8]<-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]-2*sumwx3[5]/s0[5]
b_line[9]<-6*sumx[1]/n_samP1+4*sumx[2]/n_samF1+6*sumx[3]/n_samP2-7*sumwx3[1]/s0[1]+4*sumwx3[2]/s0[2]-sumwx3[3]/s0[3]+4*sumwx3[4]/s0[4]-16*
sumwx3[5]/s0[5]+4*sumwx3[6]/s0[6]-sumwx3[7]/s0[7]+4*sumwx3[8]/s0[8]-7*sumwx3[9]/s0[9]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(B[7]+6*B[9]))/n_samP1
mean[2]<-(sumx[2]-sigma*4*B[9])/n_samF1
mean[3]<-(sumx[3]+sigma*(B[7]-6*B[9]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(-B[1]-B[3]+B[7]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*B[1])/n0[2]
mean1[3]<-(sumwx1[3]-sigma1[3]*B[2])/n0[3]
mean1[4]<-(sumwx1[4]+sigma1[4]*(B[2]+B[3]+B[7]-B[8]))/n0[4]
mean2[1]<-(sumwx2[1]-sigma2[1]*(B[4]+B[6]+B[7]+B[8]))/n0[5]
mean2[2]<-(sumwx2[2]+sigma2[2]*B[4])/n0[6]
mean2[3]<-(sumwx2[3]-sigma2[3]*B[5])/n0[7]
mean2[4]<-(sumwx2[4]+sigma2[4]*(B[5]+B[6]-B[7]))/n0[8]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[1]+B[3]+7*B[9]))/s0[1]
mean3[2]<-(sumwx3[2]-sigma3[2]*(B[1]+4*B[9]))/s0[2]
mean3[3]<-(sumwx3[3]+sigma3[3]*B[9])/s0[3]
mean3[7]<-(sumwx3[7]+sigma3[7]*B[9])/s0[7]
mean3[4]<-(sumwx3[4]+sigma3[4]*(B[2]-4*B[9]))/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-B[2]-B[3]+B[4]+B[6]+2*B[8]+16*B[9]))/s0[5]
mean3[6]<-(sumwx3[6]-sigma3[6]*(B[4]+4*B[9]))/s0[6]
mean3[8]<-(sumwx3[8]+sigma3[8]*(B[5]-4*B[9]))/s0[8]
mean3[9]<-(sumwx3[9]+sigma3[9]*(-B[5]-B[6]+7*B[9]))/s0[9]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
aa4<-sigma1[1]/(sigma1[1]+g_aa5)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2+swx1[4]*aa4^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]+aa4*n0[4]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
aaa0<-sigma2[4];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma2[4]/(sigma2[4]+g_aa5)
aa2<-sigma2[4]/(sigma2[4]+g_aa3)
aa3<-sigma2[4]/(sigma2[4]+g_aa4)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]*aa3^2+swx2[4]
as4<-aa1*n0[5]+aa2*n0[6]+aa3*n0[7]+n0[8]
sigma2[4]<-as3/as4
aaa1<-abs(sigma2[4]-aaa0)
aaa0<-sigma2[4]
if (n_iter>20) break
}
sigma50<-sigma2[4]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[4]<-sigma}
sigma2[4]<-sigma50+sigma;sigma2[1]<-sigma2[4]+g_aa5
sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[7]+swx3[9]
aa7<-s0[1]+s0[3]+s0[7]+s0[9]
n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
aa3<-sigma3[1]/(sigma3[1]+g_aa3)
aa4<-sigma3[1]/(sigma3[1]+g_aa4)
aa5<-sigma3[1]/(sigma3[1]+g_aa5)
as5<-aa6+swx3[2]*aa1^2+swx3[4]*aa2^2+swx3[5]*aa5^2+swx3[6]*aa3^2+swx3[8]*aa4^2
as6<-aa7+aa1*s0[2]+aa2*s0[4]+aa5*s0[5]+aa3*s0[6]+aa4*s0[8]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa5
sigma3[6]<-sigma3[1]+g_aa3;sigma3[8]<-sigma3[1]+g_aa4
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
n0[14]<-sigma/(sigma+sigma40+g_aa5)
s0[11]<-sigma/(sigma+sigma50+g_aa5)
s0[12]<-sigma/(sigma+sigma50+g_aa3)
s0[13]<-sigma/(sigma+sigma50+g_aa4)
s0[14]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:4)]*n0[c(11:14)]^2+swx2[c(1:4)]*s0[c(11:14)]^2)
ab4<-sum(n0[c(1:4)]*n0[c(11:14)]+n0[c(5:8)]*s0[c(11:14)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[17]<-n0[19]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1);n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-sigma/(sigma+sigma60+g_aa5);n0[16]<-sigma/(sigma+sigma60+g_aa3)
n0[18]<-sigma/(sigma+sigma60+g_aa4)
ab3<-ab3+sum(swx3[c(1:9)]*n0[c(11:19)]^2)
ab4<-ab4+sum(s0[c(1:9)]*n0[11:19])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa5
sigma2[4]<-sigma+sigma50;sigma2[1]<-sigma2[4]+g_aa5
sigma2[2]<-sigma2[4]+g_aa3;sigma2[3]<-sigma2[4]+g_aa4
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[2]<-sigma3[1]+g_aa1;sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa5;sigma3[6]<-sigma3[1]+g_aa3
sigma3[8]<-sigma3[1]+g_aa4
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*15
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,1,0,1,1,-1,-1,0,0,1,0,0,
0,-1,0,1,1,1,0,0,1,0,0,0,0.5,0.25,1,1,0,0,0.5,0,0.5,0,0,0.5,0.25,
1,0,1,0.5,0,0,0,0.5,0,0.5,0.25,1,0,0,0.5,0.5,0,0,0,0.25,0.5,0.25,
1,0,0,0.5,0.5,0,0,0,0.25,-0.5,0.25,1,0,-1,0.5,0,0,0,-0.5,0,-0.5,0.25,
1,-1,0,0,0.5,0,-0.5,0,0,-0.5,0.25,1,-1,-1,0,0,1,0,0,0,-0.5,0.25,1,1,1,
0,0,1,0,0,0,0,0.25,1,1,0,0,0.5,0,0.5,0,0,0,0.25,1,1,-1,0,0,-1,0,0,0,0,
0.25,1,0,1,0.5,0,0,0,0.5,0,0,0.25,1,0,0,0.5,0.5,0,0,0,0.25,0,0.25,1,0,-1,
0.5,0,0,0,-0.5,0,0,0.25,1,-1,1,0,0,-1,0,0,0,0,0.25,1,-1,0,0,0.5,0,-0.5,0,
0,0,0.25,1,-1,-1,0,0,1,0,0,0,0,0.25),20,11,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[4]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-ADI-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4),round(B1[4],4),round(B1[5],4),round(B1[6],4),round(B1[7],4),round(B1[8],4),round(B1[9],4),round(B1[10],4),round(B1[11],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[20]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[1],mean[4]-0.5*a1,mean[4]-a1,mean[4]-1.5*a1))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+2*a2,mean[5],mean[5]-a2,mean[5]-2*a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-matrix(0,9,1)
mean3[1]<-mean[1];mean3[2]<-mean[1]-0.5*a3;mean3[3]<-(mean[1]+mean[3])/2
mean3[4]<-mean[6]+0.6*a3;mean3[5]<-mean[6];mean3[6]<-mean3[4]
mean3[7]<-mean3[3];mean3[8]<-mean[6]-a3;mean3[9]<-mean[3]
sigma1[1]<-sigmaB1/2;sigma2[4]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,4,1)
gs[1]<-(mean1[1]+mean1[2]-mean1[3]-mean1[4]+mean2[1]+mean2[2]-
mean2[3]-mean2[4]+2*mean3[1]+2*mean3[2]+2*mean3[3]-2*mean3[7]
-2*mean3[8]-2*mean3[9])/16
gs[2]<-(mean1[1]-mean1[2]+mean1[3]-mean1[4]+mean2[1]-mean2[2]+
mean2[3]-mean2[4]+2*mean3[1]-2*mean3[3]+2*mean3[4]-2*
mean3[6]+2*mean3[7]-2*mean3[9])/16
gs[3]<-0.03846*mean[1]+0.02564*mean[2]+0.03846*mean[3]-0.19872*
mean1[1]-0.21474*mean1[2]+0.28526*mean1[3]+0.26923*mean1[4]+
0.26923*mean2[1]+0.28526*mean2[2]-0.21474*mean2[3]-0.19872*
mean2[4]-0.19872*mean3[1]-0.21474*mean3[2]-0.19872*mean3[3]+
0.28526*mean3[4]+0.26923*mean3[5]+0.28526*mean3[6]-0.19872*
mean3[7]-0.21474*mean3[8]-0.19872*mean3[9]
gs[4]<-0.03846*mean[1]+0.02564*mean[2]+0.03846*mean[3]-0.19872*
mean1[1]+0.28526*mean1[2]-0.21474*mean1[3]+0.26923*mean1[4]+
0.26923*mean2[1]-0.21474*mean2[2]+0.28526*mean2[3]-0.19872*
mean2[4]-0.19872*mean3[1]+0.28526*mean3[2]-0.19872*mean3[3]-
0.21474*mean3[4]+0.26923*mean3[5]-0.21474*mean3[6]-0.19872*
mean3[7]+0.28526*mean3[8]-0.19872*mean3[9]
g_aa1<-(0.5*gs[2]^2+0.25*gs[4]^2)/n_fam
g_aa2<-(0.5*gs[1]^2+0.25*gs[3]^2)/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
hh<-matrix(0,13,13);b_line<-matrix(0,13,1)
n0<-matrix(0,18,1);s0<-matrix(0,18,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:4)]<-mix_pi1[c(1:4)]*n_samB1;n0[c(5:8)]<-mix_pi2[c(1:4)]*n_samB2
s0[c(1:9)]<-mix_pi3[c(1:9)]*n_samF2
s0[c(1:9)][abs(s0[c(1:9)])<0.00000001]<-0.000001
n0[c(1:8)][abs(n0[c(1:8)])<0.00000001]<-0.000001
aaa0<-0;AA<-matrix(0,13,1);n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
gs[1]<-(mean1[1]+mean1[2]-mean1[3]-mean1[4]+mean2[1]+mean2[2]-
mean2[3]-mean2[4]+2*mean3[1]+2*mean3[2]+2*mean3[3]-2*mean3[7]-
2*mean3[8]-2*mean3[9])/16
gs[2]<-(mean1[1]-mean1[2]+mean1[3]-mean1[4]+mean2[1]-mean2[2]+
mean2[3]-mean2[4]+2*mean3[1]-2*mean3[3]+2*mean3[4]-2*
mean3[6]+2*mean3[7]-2*mean3[9])/16
gs[3]<-0.03846*mean[1]+0.02564*mean[2]+0.03846*mean[3]-0.19872*
mean1[1]-0.21474*mean1[2]+0.28526*mean1[3]+0.26923*mean1[4]+
0.26923*mean2[1]+0.28526*mean2[2]-0.21474*mean2[3]-0.19872*
mean2[4]-0.19872*mean3[1]-0.21474*mean3[2]-0.19872*mean3[3]+
0.28526*mean3[4]+0.26923*mean3[5]+0.28526*mean3[6]-0.19872*
mean3[7]-0.21474*mean3[8]-0.19872*mean3[9]
gs[4]<-0.03846*mean[1]+0.02564*mean[2]+0.03846*mean[3]-0.19872*
mean1[1]+0.28526*mean1[2]-0.21474*mean1[3]+0.26923*mean1[4]+
0.26923*mean2[1]-0.21474*mean2[2]+0.28526*mean2[3]-0.19872*
mean2[4]-0.19872*mean3[1]+0.28526*mean3[2]-0.19872*mean3[3]-
0.21474*mean3[4]+0.26923*mean3[5]-0.21474*mean3[6]-0.19872*
mean3[7]+0.28526*mean3[8]-0.19872*mean3[9]
g_aa1<-(0.5*gs[2]*gs[1]+0.25*gs[4]*gs[4])/n_fam
g_aa2<-(0.5*gs[1]*gs[1]+0.25*gs[3]*gs[3])/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
hh[1,1]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[1,2]<-0
hh[1,3]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[1,4]<-0
hh[1,5]<-0
hh[1,6]<-0
hh[1,7]<--sigma1[1]/n0[1]
hh[1,8]<-0
hh[1,9]<-2*sigma3[2]/s0[2]
hh[1,10]<--sigma3[1]/s0[1]
hh[1,11]<-0
hh[1,12]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]
hh[1,13]<--sigma3[1]/s0[1]-sigma3[2]/s0[2]
hh[2,2]<-sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[2,3]<-sigma1[4]/n0[4]+sigma3[5]/s0[5]
hh[2,4]<--sigma3[5]/s0[5]
hh[2,5]<-0
hh[2,6]<-hh[2,4]
hh[2,7]<-sigma1[4]/n0[4]
hh[2,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[2,9]<--2*sigma3[4]/s0[4]-8*sigma3[5]/s0[5]
hh[2,10]<-0
hh[2,11]<--2*sigma1[3]/n0[3]+4*sigma3[4]/s0[4]
hh[2,12]<--sigma1[3]/n0[3]+sigma1[4]/n0[4]
hh[2,13]<-sigma3[4]/s0[4]
hh[3,3]<-sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma3[1]/s0[1]+sigma3[5]/s0[5]
hh[3,4]<--sigma3[5]/s0[5]
hh[3,5]<-0
hh[3,6]<-hh[3,4]
hh[3,7]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[3,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[3,9]<--8*sigma3[5]/s0[5]
hh[3,10]<--sigma3[1]/s0[1]
hh[3,11]<-0
hh[3,12]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[3,13]<--sigma3[1]/s0[1]
hh[4,4]<-sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma3[5]/s0[5]+sigma3[6]/s0[6]
hh[4,5]<-0
hh[4,6]<-sigma2[1]/n0[5]+sigma3[5]/s0[5]
hh[4,7]<-sigma2[1]/n0[5]
hh[4,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[4,9]<-8*sigma3[5]/s0[5]+2*sigma3[6]/s0[6]
hh[4,10]<-0
hh[4,11]<--2*sigma2[2]/n0[6]+4*sigma3[6]/s0[6]
hh[4,12]<--sigma2[1]/n0[5]+sigma2[2]/n0[6]
hh[4,13]<-sigma3[6]/s0[6]
hh[5,5]<-sigma2[3]/n0[7]+sigma2[4]/n0[8]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[5,6]<-sigma2[4]/n0[8]+sigma3[9]/s0[9]
hh[5,7]<--sigma2[4]/n0[8]
hh[5,8]<-0
hh[5,9]<--2*sigma3[8]/s0[8]
hh[5,10]<-sigma3[9]/s0[9]
hh[5,11]<--4*sigma3[9]/s0[9]
hh[5,12]<--sigma2[3]/n0[7]+sigma2[4]/n0[8]
hh[5,13]<--sigma3[8]/s0[8]-sigma3[9]/s0[9]
hh[6,6]<-sigma2[1]/n0[5]+sigma2[4]/n0[8]+sigma3[5]/s0[5]+sigma3[9]/s0[9]
hh[6,7]<-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[6,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[6,9]<-8*sigma3[5]/s0[5]
hh[6,10]<-sigma3[9]/s0[9]
hh[6,11]<--4*sigma3[9]/s0[9]
hh[6,12]<--sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[6,13]<--sigma3[9]/s0[9]
hh[7,7]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[7,8]<--sigma1[4]/n0[4]+sigma2[1]/n0[5]
hh[7,9]<-sigma*(3/n_samP1-3/n_samP2)
hh[7,10]<-0
hh[7,11]<-sigma*(1/n_samP1+1/n_samP2)
hh[7,12]<-sigma*(3/n_samP1-3/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[7,13]<-0
hh[8,8]<-sigma1[4]/n0[4]+sigma2[1]/n0[5]+4*sigma3[5]/s0[5]
hh[8,9]<-16*sigma3[5]/s0[5]
hh[8,10]<-0
hh[8,11]<-0
hh[8,12]<--sigma1[4]/n0[4]-sigma2[1]/n0[5]
hh[8,13]<-0
hh[9,9]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma3[2]/s0[2]+16*sigma3[3]/s0[3]+4*sigma3[4]/s0[4]+64*sigma3[5]/s0[5]+4*sigma3[6]/s0[6]+16*sigma3[7]/s0[7]+4*sigma3[8]/s0[8]
hh[9,10]<-4*sigma3[3]/s0[3]+4*sigma3[7]/s0[7]
hh[9,11]<-sigma*(3/n_samP1-3/n_samP2)+4*sigma3[3]/s0[3]-8*sigma3[4]/s0[4]+8*sigma3[6]/s0[6]-20*sigma3[7]/s0[7]
hh[9,12]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)
hh[9,13]<--2*sigma3[2]/s0[2]-2*sigma3[4]/s0[4]+2*sigma3[6]/s0[6]+2*sigma3[8]/s0[8]
hh[10,10]<-sigma3[1]/s0[1]+sigma3[3]/s0[3]+sigma3[7]/s0[7]+sigma3[9]/s0[9]
hh[10,11]<-sigma3[3]/s0[3]-5*sigma3[7]/s0[7]-4*sigma3[9]/s0[9]
hh[10,12]<-0
hh[10,13]<-sigma3[1]/s0[1]-sigma3[9]/s0[9]
hh[11,11]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[3]/n0[3]+4*sigma2[2]/n0[6]+sigma3[3]/s0[3]+16*sigma3[4]/s0[4]+16*sigma3[6]/s0[6]+25*sigma3[7]/s0[7]+16*sigma3[9]/s0[9]
hh[11,12]<-sigma*(3/n_samP1-3/n_samP2)+2*sigma1[3]/n0[3]-2*sigma2[2]/n0[6]
hh[11,13]<-4*(sigma3[4]/s0[4]+sigma3[6]/s0[6]+sigma3[9]/s0[9])
hh[12,12]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma2[3]/n0[7]+sigma2[4]/n0[8]
hh[12,13]<-0
hh[13,13]<-sigma3[1]/s0[1]+sigma3[2]/s0[2]+sigma3[4]/s0[4]+sigma3[6]/s0[6]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
for(i in 2:13)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2]
b_line[2]<-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]-sumwx3[1]/s0[1]+sumwx3[5]/s0[5]
b_line[4]<-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
b_line[5]<-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]-sumwx3[8]/s0[8]+sumwx3[9]/s0[9]
b_line[6]<-sumwx2[1]/n0[5]-sumwx2[4]/n0[8]-sumwx3[5]/s0[5]+sumwx3[9]/s0[9]
b_line[7]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]+sumwx2[4]/n0[8]
b_line[8]<-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]-2*sumwx3[5]/s0[5]
b_line[9]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2+2*sumwx3[2]/s0[2]-4*sumwx3[3]/s0[3]+2*sumwx3[4]/s0[4]+2*sumwx3[6]/s0[6]-4*sumwx3[7]/s0[7]+2*sumwx3[8]/s0[8]-8*sumwx3[5]/s0[5]
b_line[10]<-sumwx3[1]/s0[1]-sumwx3[3]/s0[3]-sumwx3[7]/s0[7]+sumwx3[9]/s0[9]
b_line[11]<-sumx[1]/n_samP1-sumx[3]/n_samP2-2*sumwx1[3]/n0[3]+2*sumwx2[2]/n0[6]-sumwx3[3]/s0[3]-4*sumwx3[4]/s0[4]+4*sumwx3[6]/s0[6]+5*sumwx3[7]/s0[7]-4*sumwx3[9]/s0[9]
b_line[12]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]
b_line[13]<-sumwx3[1]/s0[1]-sumwx3[2]/s0[2]-sumwx3[4]/s0[4]+sumwx3[6]/s0[6]+sumwx3[8]/s0[8]-sumwx3[9]/s0[9]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]+sigma*(-B[7]-3*B[9]-B[11]-3*B[12]))/n_samP1
mean[2]<-(sumx[2]+sigma*(-2*B[9]-2*B[12]))/n_samF1
mean[3]<-(sumx[3]+sigma*(B[7]-3*B[9]+B[11]-3*B[12]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(-B[1]-B[3]+B[7]+B[12]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[1]+B[12]))/n0[2]
mean1[3]<-(sumwx1[3]+sigma1[3]*(-B[2]+2*B[11]+B[12]))/n0[3]
mean1[4]<-(sumwx1[4]+sigma1[4]*(B[2]+B[3]+B[7]-B[8]+B[12]))/n0[4]
mean2[1]<-(sumwx2[1]+sigma2[1]*(-B[4]-B[6]-B[7]-B[8]+B[12]))/n0[5]
mean2[2]<-(sumwx2[2]+sigma2[2]*(B[4]-2*B[11]+B[12]))/n0[6]
mean2[3]<-(sumwx2[3]+sigma2[3]*(-B[5]+B[12]))/n0[7]
mean2[4]<-(sumwx2[4]+sigma2[4]*(B[5]+B[6]-B[7]+B[12]))/n0[8]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[1]+B[3]-B[10]-B[13]))/s0[1]
mean3[2]<-(sumwx3[2]+sigma3[2]*(-B[1]-2*B[9]+B[13]))/s0[2]
mean3[3]<-(sumwx3[3]+sigma3[3]*(4*B[9]+B[10]+B[11]))/s0[3]
mean3[7]<-(sumwx3[7]+sigma3[7]*(4*B[9]+B[10]-5*B[11]))/s0[7]
mean3[4]<-(sumwx3[4]+sigma3[4]*(B[2]-2*B[9]+4*B[11]+B[13]))/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-B[2]-B[3]+B[4]+B[6]+2*B[8]+8*B[9]))/s0[5]
mean3[6]<-(sumwx3[6]+sigma3[6]*(-B[4]-2*B[9]-4*B[11]-B[13]))/s0[6]
mean3[8]<-(sumwx3[8]+sigma3[8]*(B[5]-2*B[9]-B[13]))/s0[8]
mean3[9]<-(sumwx3[9]+sigma3[9]*(-B[5]-B[6]-B[10]+4*B[11]+B[13]))/s0[9]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
aa4<-sigma1[1]/(sigma1[1]+g_aa3)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2+swx1[4]*aa4^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]+aa4*n0[4]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
aaa0<-sigma2[4];n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma2[4]/(sigma2[4]+g_aa3)
aa2<-sigma2[4]/(sigma2[4]+g_aa2)
aa3<-sigma2[4]/(sigma2[4]+g_aa1)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]*aa3^2+swx2[4]
as4<-aa1*n0[5]+aa2*n0[6]+aa3*n0[7]+n0[8]
sigma2[4]<-as3/as4
aaa1<-abs(sigma2[4]-aaa0)
aaa0<-sigma2[4]
if (n_iter>20) break
}
sigma50<-sigma2[4]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[4]<-sigma}
sigma2[4]<-sigma50+sigma;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[7]+swx3[9]
aa7<-s0[1]+s0[3]+s0[7]+s0[9]
n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
aa3<-sigma3[1]/(sigma3[1]+g_aa3)
as5<-aa6+(swx3[2]+swx3[8])*aa1^2+(swx3[4]+swx3[6])*aa2^2+swx3[5]*aa3^2
as6<-aa7+aa1*(s0[2]+s0[8])+aa2*(s0[4]+s0[6])+aa3*s0[5]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1];sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa3;sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
n0[14]<-sigma/(sigma+sigma40+g_aa3)
s0[11]<-sigma/(sigma+sigma50+g_aa3)
s0[12]<-sigma/(sigma+sigma50+g_aa2)
s0[13]<-sigma/(sigma+sigma50+g_aa1)
s0[14]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:4)]*n0[c(11:14)]^2+swx2[c(1:4)]*s0[c(11:14)]^2)
ab4<-sum(n0[c(1:4)]*n0[c(11:14)]+n0[c(5:8)]*s0[c(11:14)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[17]<-n0[19]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1);n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-sigma/(sigma+sigma60+g_aa3);n0[16]<-sigma/(sigma+sigma60+g_aa2)
n0[18]<-sigma/(sigma+sigma60+g_aa1)
ab3<-ab3+sum(swx3[c(1:9)]*n0[c(11:19)]^2)
ab4<-ab4+sum(s0[c(1:9)]*n0[11:19])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
sigma2[4]<-sigma+sigma50;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[2]<-sigma3[1]+g_aa1;sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa3;sigma3[6]<-sigma3[1]+g_aa2
sigma3[8]<-sigma3[1]+g_aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*11
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,0,0,1,0,1,0,0,1,1,0,1,1,-1,-1,0,0,-1,0,1,1,1,0,0,0.5,0.25,1,1,0,0,0.5,0.5,0.25,1,0,1,0.5,0,0.5,0.25,
1,0,0,0.5,0.5,0.5,0.25,1,0,0,0.5,0.5,-0.5,0.25,1,0,-1,0.5,0,-0.5,0.25,1,-1,0,0,0.5,-0.5,0.25,1,-1,-1,0,0,-0.5,
0.25,1,1,1,0,0,0,0.25,1,1,0,0,0.5,0,0.25,1,1,-1,0,0,0,0.25,1,0,1,0.5,0,0,0.25,1,0,0,0.5,0.5,0,0.25,1,0,-1,0.5,
0,0,0.25,1,-1,1,0,0,0,0.25,1,-1,0,0,0.5,0,0.25,1,-1,-1,0,0,0,0.25),20,7,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[4]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-AD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4),round(B1[4],4),round(B1[5],4)," "," "," "," ",round(B1[6],4),round(B1[7],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[21]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1)
sigma<-sigma0
a1<-sqrt(sigma40/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[1],mean[4]-0.5*a1,mean[4]-0.8*a1,mean[2]))
a2<-sqrt(sigma50/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[2],mean[5]-0.5*a2,mean[5]-a2,mean[3]))
a3<-sqrt(sigma60/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-matrix(0,9,1)
mean3[1]<-mean3[2]<-mean[1];mean3[3]<-(mean[1]+mean[3])/2
mean3[4]<-mean[6]+0.6*a3;mean3[5]<-mean[6]
mean3[6]<-mean3[4];mean3[7]<-mean3[3]
mean3[8]<-mean[6]-a3;mean3[9]<-mean[3]
sigma1[1]<-sigmaB1/2;sigma2[4]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,2,1)
gs[1]<-(mean1[1]+mean1[2]-mean1[3]-mean1[4]+mean2[1]+mean2[2]-
mean2[3]-mean2[4]+2*mean3[1]+2*mean3[2]+2*mean3[3]-2*mean3[7]-
2*mean3[8]-2*mean3[9])/16
gs[2]<-(mean1[1]-mean1[2]+mean1[3]-mean1[4]+mean2[1]-mean2[2]+
mean2[3]-mean2[4]+2*mean3[1]-2*mean3[3]+2*mean3[4]-2*
mean3[6]+2*mean3[7]-2*mean3[9])/16
g_aa1<-0.5*gs[2]*gs[2]/n_fam
g_aa2<-0.5*gs[1]*gs[1]/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
hh<-matrix(0,15,15);b_line<-matrix(0,15,1)
n0<-matrix(0,18,1);s0<-matrix(0,18,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:4)]<-mix_pi1[c(1:4)]*n_samB1;n0[c(5:8)]<-mix_pi2[c(1:4)]*n_samB2
s0[c(1:9)]<-mix_pi3[c(1:9)]*n_samF2
s0[c(1:9)][abs(s0[c(1:9)])<0.00000001]<-0.000001
n0[c(1:8)][abs(n0[c(1:8)])<0.00000001]<-0.000001
aaa0<-0 ;AA<-matrix(0,15,1);n_iter<-0;aaa1<-1000
while(aaa1>0.001)
{
n_iter<-n_iter+1
gs[1]<-(mean1[1]+mean1[2]-mean1[3]-mean1[4]+mean2[1]+mean2[2]-
mean2[3]-mean2[4]+2*mean3[1]+2*mean3[2]+2*mean3[3]-2*mean3[7]-
2*mean3[8]-2*mean3[9])/16
gs[2]<-(mean1[1]-mean1[2]+mean1[3]-mean1[4]+mean2[1]-mean2[2]+
mean2[3]-mean2[4]+2*mean3[1]-2*mean3[3]+2*mean3[4]-2*
mean3[6]+2*mean3[7]-2*mean3[9])/16
g_aa1<-0.5*gs[2]*gs[2]/n_fam
g_aa2<-0.5*gs[1]*gs[1]/n_fam
g_aa3<-g_aa1+g_aa2
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+64*sigma3[5]/s0[5]
hh[1,2]<-0
hh[1,3]<--8*sigma3[5]/s0[5]
hh[1,4]<-hh[1,3]
hh[1,5]<--hh[1,3]
hh[1,6]<-0
hh[1,7]<-hh[1,5]
hh[1,8]<-sigma*(3/n_samP1-3/n_samP2)
hh[1,9]<-16*sigma3[5]/s0[5]
hh[1,10]<-0
hh[1,11]<-0
hh[1,12]<-0
hh[1,13]<-0
hh[1,14]<-48*sigma3[5]/s0[5]
hh[1,15]<-0
hh[2,2]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[2,3]<-0
hh[2,4]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[2,5]<-0
hh[2,6]<-0
hh[2,7]<-hh[2,6]
hh[2,8]<--sigma1[1]/n0[1]
hh[2,9]<-0
hh[2,10]<-sigma3[2]/s0[2]
hh[2,11]<--sigma3[1]/s0[1]
hh[2,12]<-0
hh[2,13]<-hh[2,11]
hh[2,14]<-sigma1[1]/n0[1]-2*sigma1[2]/n0[2]
hh[2,15]<--sigma1[2]/n0[2]
hh[3,3]<-sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[3,4]<-sigma1[4]/n0[4]+sigma3[5]/s0[5]
hh[3,5]<--sigma3[5]/s0[5]
hh[3,6]<-0
hh[3,7]<--sigma3[5]/s0[5]
hh[3,8]<-sigma1[4]/n0[4]
hh[3,9]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[3,10]<-0
hh[3,11]<-0
hh[3,12]<--sigma3[4]/s0[4]
hh[3,13]<-2*sigma3[4]/s0[4]
hh[3,14]<--6*sigma3[5]/s0[5]
hh[3,15]<--sigma1[3]/n0[3]
hh[4,4]<-sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma3[1]/s0[1]+sigma3[5]/s0[5]
hh[4,5]<--sigma3[5]/s0[5]
hh[4,6]<-0
hh[4,7]<-hh[4,5]
hh[4,8]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[4,9]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[4,10]<-0
hh[4,11]<--sigma3[1]/s0[1]
hh[4,12]<-0
hh[4,13]<--sigma3[1]/s0[1]
hh[4,14]<-sigma1[1]/n0[1]-6*sigma3[5]/s0[5]
hh[4,15]<-0
hh[5,5]<-sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma3[5]/s0[5]+sigma3[6]/s0[6]
hh[5,6]<-0
hh[5,7]<-sigma2[1]/n0[5]+sigma3[5]/s0[5]
hh[5,8]<-sigma2[1]/n0[5]
hh[5,9]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[5,10]<-0
hh[5,11]<-0
hh[5,12]<--sigma3[6]/s0[6]
hh[5,13]<-0
hh[5,14]<-6*sigma3[5]/s0[5]
hh[5,15]<-sigma2[2]/n0[6]
hh[6,6]<-sigma2[3]/n0[7]+sigma2[4]/n0[8]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[6,7]<-sigma2[4]/n0[8]+sigma3[9]/s0[9]
hh[6,8]<--sigma2[4]/n0[8]
hh[6,9]<-0
hh[6,10]<--sigma3[8]/s0[8]
hh[6,11]<-sigma3[9]/s0[9]
hh[6,12]<-hh[6,11]
hh[6,13]<--2*sigma3[8]/s0[8]-sigma3[9]/s0[9]
hh[6,14]<-2*sigma2[3]/n0[7]-sigma2[4]/n0[8]
hh[6,15]<-sigma2[3]/n0[7]
hh[7,7]<-sigma2[1]/n0[5]+sigma2[4]/n0[8]+sigma3[5]/s0[5]+sigma3[9]/s0[9]
hh[7,8]<-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[7,9]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[7,10]<-0
hh[7,11]<-sigma3[9]/s0[9]
hh[7,12]<-hh[7,11]
hh[7,13]<--hh[7,11]
hh[7,14]<--sigma2[4]/n0[8]+6*sigma3[5]/s0[5]
hh[7,15]<-0
hh[8,8]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[8,9]<--sigma1[4]/n0[4]+sigma2[1]/n0[5]
hh[8,10]<-0
hh[8,11]<-hh[8,10]
hh[8,12]<-hh[8,10]
hh[8,13]<-hh[8,10]
hh[8,14]<--sigma1[1]/n0[1]+sigma2[4]/n0[8]
hh[8,15]<-0
hh[9,9]<-sigma1[4]/n0[4]+sigma2[1]/n0[5]+4*sigma3[5]/s0[5]
hh[9,10]<-0
hh[9,11]<-0
hh[9,12]<-0
hh[9,13]<-0
hh[9,14]<-12*sigma3[5]/s0[5]
hh[9,15]<-0
hh[10,10]<-sigma3[2]/s0[2]+sigma3[3]/s0[3]+sigma3[7]/s0[7]+sigma3[8]/s0[8]
hh[10,11]<-sigma3[3]/s0[3]+sigma3[7]/s0[7]
hh[10,12]<-sigma3[7]/s0[7]
hh[10,13]<-2*sigma3[8]/s0[8]
hh[10,14]<-0
hh[10,15]<-0
hh[11,11]<-sigma3[1]/s0[1]+sigma3[3]/s0[3]+sigma3[7]/s0[7]+sigma3[9]/s0[9]
hh[11,12]<-sigma3[7]/s0[7]+sigma3[9]/s0[9]
hh[11,13]<-sigma3[1]/s0[1]-sigma3[9]/s0[9]
hh[11,14]<-0
hh[11,15]<-0
hh[12,12]<-sigma3[4]/s0[4]+sigma3[6]/s0[6]+sigma3[7]/s0[7]+sigma3[9]/s0[9]
hh[12,13]<--2*sigma3[4]/s0[4]-sigma3[9]/s0[9]
hh[12,14]<-0
hh[12,15]<-0
hh[13,13]<-sigma3[1]/s0[1]+4*sigma3[4]/s0[4]+4*sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[13,14]<-0
hh[13,15]<-0
hh[14,14]<-sigma1[1]/n0[1]+4*sigma1[2]/n0[2]+4*sigma2[3]/n0[7]+sigma2[4]/n0[8]+36*sigma3[5]/s0[5]
hh[14,15]<-2*sigma1[2]/n0[2]+2*sigma2[3]/n0[7]
hh[15,15]<-sigma1[2]/n0[2]+sigma1[3]/n0[3]+sigma2[2]/n0[6]+sigma2[3]/n0[7]
for(i in 2:15)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-8*sumwx3[5]/s0[5]
b_line[2]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2]
b_line[3]<-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[4]<-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]-sumwx3[1]/s0[1]+sumwx3[5]/s0[5]
b_line[5]<-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
b_line[6]<-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]-sumwx3[8]/s0[8]+sumwx3[9]/s0[9]
b_line[7]<-sumwx2[1]/n0[5]-sumwx2[4]/n0[8]-sumwx3[5]/s0[5]+sumwx3[9]/s0[9]
b_line[8]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]+sumwx2[4]/n0[8]
b_line[9]<-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]-2*sumwx3[5]/s0[5]
b_line[10]<-sumwx3[2]/s0[2]-sumwx3[3]/s0[3]-sumwx3[7]/s0[7]+sumwx3[8]/s0[8]
b_line[11]<-sumwx3[1]/s0[1]-sumwx3[3]/s0[3]-sumwx3[7]/s0[7]+sumwx3[9]/s0[9]
b_line[12]<-sumwx3[4]/s0[4]-sumwx3[6]/s0[6]-sumwx3[7]/s0[7]+sumwx3[9]/s0[9]
b_line[13]<-sumwx3[1]/s0[1]-2*sumwx3[4]/s0[4]+2*sumwx3[8]/s0[8]-sumwx3[9]/s0[9]
b_line[14]<-sumwx1[1]/n0[1]+2*sumwx1[2]/n0[2]+2*sumwx2[3]/n0[7]+sumwx2[4]/n0[8]-6*sumwx3[5]/s0[5]
b_line[15]<-sumwx1[2]/n0[2]-sumwx1[3]/n0[3]-sumwx2[2]/n0[6]+sumwx2[3]/n0[7]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]+sigma*(-3*B[1]-B[8]))/n_samP1
mean[2]<-(sumx[2]+sigma*(-2*B[1]))/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[8]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(-B[2]-B[4]+B[8]-B[14]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[2]-2*B[14]-B[15]))/n0[2]
mean1[3]<-(sumwx1[3]+sigma1[3]*(-B[3]+B[15]))/n0[3]
mean1[4]<-(sumwx1[4]+sigma1[4]*(B[3]+B[4]+B[8]-B[9]))/n0[4]
mean2[1]<-(sumwx2[1]+sigma2[1]*(-B[5]-B[7]-B[8]-B[9]))/n0[5]
mean2[2]<-(sumwx2[2]+sigma2[2]*(B[5]+B[15]))/n0[6]
mean2[3]<-(sumwx2[3]+sigma2[3]*(-B[6]-2*B[14]-B[15]))/n0[7]
mean2[4]<-(sumwx2[4]+sigma2[4]*(B[6]+B[7]-B[8]-B[14]))/n0[8]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[2]+B[4]-B[11]-B[13]))/s0[1]
mean3[2]<-(sumwx3[2]+sigma3[2]*(-B[2]-B[10]))/s0[2]
mean3[3]<-(sumwx3[3]+sigma3[3]*(B[10]+B[11]))/s0[3]
mean3[7]<-(sumwx3[7]+sigma3[7]*(B[10]+B[11]+B[12]))/s0[7]
mean3[4]<-(sumwx3[4]+sigma3[4]*(B[3]-B[12]+2*B[13]))/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(8*B[1]-B[3]-B[4]+B[5]+B[7]+2*B[9]+6*B[14]))/s0[5]
mean3[6]<-(sumwx3[6]+sigma3[6]*(-B[5]+B[12]))/s0[6]
mean3[8]<-(sumwx3[8]+sigma3[8]*(B[6]-B[10]-2*B[13]))/s0[8]
mean3[9]<-(sumwx3[9]+sigma3[9]*(-B[6]-B[7]-B[11]-B[12]+B[13]))/s0[9]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
aa4<-sigma1[1]/(sigma1[1]+g_aa3)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2+swx1[4]*aa4^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]+aa4*n0[4]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
aaa0<-sigma2[4];n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma2[4]/(sigma2[4]+g_aa3)
aa2<-sigma2[4]/(sigma2[4]+g_aa2)
aa3<-sigma2[4]/(sigma2[4]+g_aa1)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]*aa3^2+swx2[4]
as4<-aa1*n0[5]+aa2*n0[6]+aa3*n0[7]+n0[8]
sigma2[4]<-as3/as4
aaa1<-abs(sigma2[4]-aaa0)
aaa0<-sigma2[4]
if (n_iter>20) break
}
sigma50<-sigma2[4]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[4]<-sigma}
sigma2[4]<-sigma50+sigma;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[7]+swx3[9]
aa7<-s0[1]+s0[3]+s0[7]+s0[9]
n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
aa3<-sigma3[1]/(sigma3[1]+g_aa3)
as5<-aa6+(swx3[2]+swx3[8])*aa1^2+(swx3[4]+swx3[6])*aa2^2+swx3[5]*aa3^2
as6<-aa7+aa1*(s0[2]+s0[8])+aa2*(s0[4]+s0[6])+aa3*s0[5]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1];sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa3;sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
n0[14]<-sigma/(sigma+sigma40+g_aa3)
s0[11]<-sigma/(sigma+sigma50+g_aa3)
s0[12]<-sigma/(sigma+sigma50+g_aa2)
s0[13]<-sigma/(sigma+sigma50+g_aa1)
s0[14]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:4)]*n0[c(11:14)]^2+swx2[c(1:4)]*s0[c(11:14)]^2)
ab4<-sum(n0[c(1:4)]*n0[c(11:14)]+n0[c(5:8)]*s0[c(11:14)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[17]<-n0[19]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1);n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-sigma/(sigma+sigma60+g_aa3);n0[16]<-sigma/(sigma+sigma60+g_aa2)
n0[18]<-sigma/(sigma+sigma60+g_aa1)
ab3<-ab3+sum(swx3[c(1:9)]*n0[c(11:19)]^2)
ab4<-ab4+sum(s0[c(1:9)]*n0[11:19])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
sigma2[4]<-sigma+sigma50;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[2]<-sigma3[1]+g_aa1;sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa3;sigma3[6]<-sigma3[1]+g_aa2;sigma3[8]<-sigma3[1]+g_aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*9
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,1,0,1,0,0,0,1,1,-1,-1,-1,0,1,1,1,0.5,0.25,1,1,0,0.5,0.25,1,0,1,0.5,0.25,
1,0,0,0.5,0.25,1,0,0,-0.5,0.25,1,0,-1,-0.5,0.25,1,-1,0,-0.5,0.25,1,-1,-1,-0.5,
0.25,1,1,1,0,0.25,1,1,0,0,0.25,1,1,-1,0,0.25,1,0,1,0,0.25,1,0,0,0,0.25,1,0,-1,0,
0.25,1,-1,1,0,0.25,1,-1,0,0,0.25,1,-1,-1,0,0.25),20,5,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[4]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-A-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4)," "," "," "," "," "," ",round(B1[4],4),round(B1[5],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[22]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-as.matrix(c(0.25,0.5,0.25));sigma1<-matrix(0,3,1)
mi2<-as.matrix(c(0.25,0.5,0.25));sigma2<-matrix(0,3,1)
mi3<-as.matrix(c(0.0625,0.25,0.125,0.25,0.25,0.0625))
sigma3<-matrix(0,6,1)
sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) {a1<--a1}
mean1<-as.matrix(c(mean[1],mean[4],mean[4]-1.2*a1))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) {a2<--a2}
mean2<-as.matrix(c(mean[2]+0.5*a1,mean[5],mean[5]-1.2*a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]){a3<--a3}
mean3<-as.matrix(c(mean[1],mean[4],mean[2],mean[2],mean[5],mean[2]))
sigma1[1]<-sigmaB1/2;sigma2[3]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,1,1)
gs[1]<-(mean1[1]-mean1[3]+mean2[1]-mean2[3]+2*mean3[1]+mean3[2]-mean3[5]-2*mean3[6])/14
g_aa1<-0.5*gs[1]^2/n_fam
g_aa2<-gs[1]^2/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[6]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa1
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,3,n_samB1); swx1 <- matrix(0,3,1)
W2 <- matrix(0,3,n_samB2); swx2 <- matrix(0,3,1)
W3 <- matrix(0,6,n_samF2); swx3 <- matrix(0,6,1)
hh<-matrix(0,10,10);b_line<-matrix(0,10,1)
n0<-matrix(0,15,1);s0<-matrix(0,15,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:3) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:3) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:6) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:3)]<-mix_pi1[c(1:3)]*n_samB1;n0[c(4:6)]<-mix_pi2[c(1:3)]*n_samB2
s0[c(1:6)]<-mix_pi3[c(1:6)]*n_samF2
s0[c(1:6)][abs(s0[c(1:6)])<0.00000001]<-0.000001
n0[c(1:6)][abs(n0[c(1:6)])<0.00000001]<-0.000001
aaa0<-0;AA<-matrix(0,10,1);n_iter<-0
aaa1<-1000
while(aaa1>0.001)
{
n_iter<-n_iter+1;
gs[1]<-(mean1[1]-mean1[3]+mean2[1]-mean2[3]+2*mean3[1]+mean3[2]-mean3[5]-2*mean3[6])/14
g_aa1<-0.5*gs[1]^2/n_fam
g_aa2<-gs[1]^2/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[6]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa1
aa11<-sigma3[4]*sumwx3[3]+sigma3[3]*sumwx3[4]
aa12<-sigma3[4]*s0[3]+sigma3[3]*s0[4]
aa13<-sigma3[3]*sigma3[4]
hh[1,1]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+64*aa13/aa12
hh[1,2]<-sigma*(3/n_samP1-3/n_samP2)
hh[1,3]<-hh[1,2]
hh[1,4]<-hh[1,2]
hh[1,5]<--8*aa13/aa12
hh[1,6]<-0
hh[1,7]<-16*aa13/aa12
hh[1,8]<-hh[1,7]
hh[1,9]<-0.5*hh[1,7]
hh[1,10]<-hh[1,7]
hh[2,2]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[1]/n0[1]+36*sigma1[2]/n0[2]+36*sigma3[5]/s0[5]+4*sigma3[6]/s0[6]
hh[2,3]<-sigma*(1/n_samP1+1/n_samP2)-2*sigma1[1]/n0[1]
hh[2,4]<-sigma*(1/n_samP1+1/n_samP2)+12*sigma1[2]/n0[2]
hh[2,5]<-2*sigma1[1]/n0[1]
hh[2,6]<-2*sigma1[1]/n0[1]+6*sigma1[2]/n0[2]
hh[2,7]<--6*sigma1[2]/n0[2]
hh[2,8]<-0
hh[2,9]<-6*sigma3[5]/s0[5]
hh[2,10]<--2*sigma3[6]/s0[6]
hh[3,3]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[3]/n0[3]+sigma2[1]/n0[4]+sigma2[3]/n0[6]
hh[3,4]<-sigma*(1/n_samP1+1/n_samP2)
hh[3,5]<--sigma1[1]/n0[1]+sigma1[3]/n0[3]
hh[3,6]<--sigma1[1]/n0[1]
hh[3,7]<-0
hh[3,8]<--sigma1[3]/n0[3]+sigma2[1]/n0[4]
hh[3,9]<-sigma2[1]/n0[4]
hh[3,10]<-0
hh[4,4]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[2]/n0[2]+4*sigma2[2]/n0[5]
hh[4,5]<-0
hh[4,6]<-2*sigma1[2]/n0[2]
hh[4,7]<--2*sigma1[2]/n0[2]+2*sigma2[2]/n0[5]
hh[4,8]<-0
hh[4,9]<--2*sigma2[2]/n0[5]
hh[4,10]<-0
hh[5,5]<-sigma1[1]/n0[1]+sigma1[3]/n0[3]+sigma3[1]/s0[1]+aa13/aa12
hh[5,6]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[5,7]<--2*aa13/aa12
hh[5,8]<--sigma1[3]/n0[3]-2*aa13/aa12
hh[5,9]<--aa13/aa12
hh[5,10]<--sigma3[1]/s0[1]-2*aa13/aa12
hh[6,6]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[6,7]<--sigma1[2]/n0[2]
hh[6,8]<-0
hh[6,9]<-0
hh[6,10]<--sigma3[1]/s0[1]
hh[7,7]<-sigma1[2]/n0[2]+sigma2[2]/n0[5]+4*aa13/aa12
hh[7,8]<-4*aa13/aa12
hh[7,9]<--sigma2[2]/n0[5]+2*aa13/aa12
hh[7,10]<-4*aa13/aa12
hh[8,8]<-sigma1[3]/n0[3]+sigma2[1]/n0[4]+4*aa13/aa12
hh[8,9]<-sigma2[1]/n0[4]+2*aa13/aa12
hh[8,10]<-4*aa13/aa12
hh[9,9]<-sigma2[1]/n0[4]+sigma2[2]/n0[5]+aa13/aa12+sigma3[5]/s0[5]
hh[9,10]<-2*aa13/aa12
hh[10,10]<-sigma3[1]/s0[1]+sigma3[6]/s0[6]+4*aa13/aa12
for(i in 2:10)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-8*aa11/aa12;
b_line[2]<-sumx[1]/n_samP1-sumx[3]/n_samP2+2*sumwx1[1]/n0[1]-6*sumwx1[2]/n0[2]+6*sumwx3[5]/s0[5]-2*sumwx3[6]/s0[6];
b_line[3]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[3]/n0[3]+sumwx2[1]/n0[4]+sumwx2[3]/n0[6];
b_line[4]<-sumx[1]/n_samP1-sumx[3]/n_samP2-2*sumwx1[2]/n0[2]+2*sumwx2[2]/n0[5];
b_line[5]<-sumwx1[1]/n0[1]-sumwx1[3]/n0[3]-sumwx3[1]/s0[1]+aa11/aa12;
b_line[6]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2];
b_line[7]<-sumwx1[2]/n0[2]+sumwx2[2]/n0[5]-2*aa11/aa12;
b_line[8]<-sumwx1[3]/n0[3]+sumwx2[1]/n0[4]-2*aa11/aa12;
b_line[9]<-sumwx2[1]/n0[4]-sumwx2[2]/n0[5]-aa11/aa12+sumwx3[5]/s0[5];
b_line[10]<-sumwx3[1]/s0[1]-2*aa11/aa12+sumwx3[6]/s0[6];
B<-solve(hh,b_line)
mean[1]<-(sumx[1]+sigma*(-3*B[1]-B[2]-B[3]-B[4]))/n_samP1
mean[2]<-(sumx[2]-sigma*2*B[1])/n_samF1
mean[3]<-(sumx[3]+sigma*(-3*B[1]+B[2]+B[3]+B[4]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(-2*B[2]+B[3]-B[5]-B[6]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(6*B[2]+2*B[4]+B[6]-B[7]))/n0[2]
mean1[3]<-(sumwx1[3]+sigma1[3]*(B[3]+B[5]-B[8]))/n0[3]
mean2[1]<-(sumwx2[1]+sigma2[1]*(-B[3]-B[8]-B[9]))/n0[4]
mean2[2]<-(sumwx2[2]+sigma2[2]*(-2*B[4]-B[7]+B[9]))/n0[5]
mean2[3]<-(sumwx2[3]-sigma2[3]*B[3])/n0[6]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[5]+B[6]-B[10]))/s0[1]
mean3[2]<-(sumwx3[2]+sigma3[2]*(-B[6]))/s0[2]
mean3[3]<-(sigma3[4]*sumwx3[3]+sigma3[3]*sumwx3[4]+sigma3[3]*sigma3[4]*(8*B[1]-B[5]+2*B[7]+2*B[8]+B[9]+2*B[10]))/(sigma3[4]*s0[3]+sigma3[3]*s0[4])
mean3[4]<-mean3[3]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-6*B[2]-B[9]))/s0[5]
mean3[6]<-(sumwx3[6]+sigma3[6]*(2*B[2]-B[10]))/s0[6]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:3) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:3) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:6) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
aaa0<-sigma2[3];n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma2[3]/(sigma2[3]+g_aa2)
aa2<-sigma2[3]/(sigma2[3]+g_aa1)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]
as4<-aa1*n0[4]+aa2*n0[5]+n0[6]
sigma2[3]<-as3/as4
aaa1<-abs(sigma2[3]-aaa0)
aaa0<-sigma2[3]
if (n_iter>20) break
}
sigma50<-sigma2[3]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[3]<-sigma}
sigma2[3]<-sigma+sigma50;sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[6];aa7<-s0[1]+s0[3]+s0[6]
n_iter<-0;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
as5<-aa6+(swx3[2]+swx3[5])*aa1^2+swx3[4]*aa2^2
as6<-aa7+aa1*(s0[2]+s0[5])+aa2*s0[4]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma+sigma60;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[6]<-sigma3[1];sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa1
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
s0[11]<-sigma/(sigma+sigma50+g_aa2)
s0[12]<-sigma/(sigma+sigma50+g_aa1)
s0[13]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:3)]*n0[c(11:13)]^2+swx2[c(1:3)]*s0[c(11:13)]^2)
ab4<-sum(n0[c(1:3)]*n0[c(11:13)]+n0[c(4:6)]*s0[c(11:13)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[16]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1)
n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-sigma/(sigma+sigma60+g_aa1)
ab3<-ab3+sum(swx3[c(1:6)]*n0[c(11:16)]^2)
ab4<-ab4+sum(s0[c(1:6)]*n0[11:16])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma2[3]<-sigma+sigma50
sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[1]<-sigma+sigma60;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[6]<-sigma3[1];sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[1]+g_aa1
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*8
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,3)
for(i in 1:3){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,3)
for(i in 1:3){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,6)
for(i in 1:6){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,2,1,0,1,0,0,1,1,-2,-1,0,1,2,0.5,0.25,1,1,0.5,0.25,
1,0,0.5,0.25,1,0,-0.5,0.25,1,-1,-0.5,0.25,1,-2,-0.5,0.25,
1,2,0,0.25,1,1,0,0.25,1,0,0,0.25,1,-1,0,0.25,1,-2,0,0.25),14,4,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean2[1],mean2[2],mean2[3],mean3[1],mean3[2],mean3[3],mean3[5],mean3[6]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[3]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[3]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-EA-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," ",round(t(sigma1),4)," ",
round(t(mix_pi1),4)," ",round(t(mean2),4)," ",round(t(sigma2),4)," ",round(t(mix_pi2),4)," ",
round(t(mean3),4)," "," "," ",round(t(sigma3),4)," "," "," ",round(t(mix_pi3),4)," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[2],4)," "," "," "," "," "," ",round(B1[3],4),round(B1[4],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[23]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-matrix(0.25,4,1);sigma1<-matrix(0,4,1)
mi2<-matrix(0.25,4,1);sigma2<-matrix(0,4,1)
mi3<-as.matrix(c(0.0625,0.125,0.0625,0.125,0.25,0.125,0.0625,0.125,0.0625))
sigma3<-matrix(0,9,1);sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) a1<--a1
mean1<-as.matrix(c(mean[1],mean[4]-0.5*a1,mean[4]-a1,mean[4]-1.5*a1))
a2<-sqrt(sigma50/n_samB2);if (mean[1]<mean[3]) a2<--a2
mean2<-as.matrix(c(mean[5]+a2,mean[5],mean[5]-a2,mean[5]-2*a2))
a3<-sqrt(sigma60/n_samF2);if (mean[1]<mean[3]) a3<--a3
mean3<-matrix(0,9,1)
mean3[1]<-mean[1];mean3[2]<-mean[1]-0.5*a3
mean3[3]<-(mean[1]+mean[3])/2;mean3[4]<-mean[6]+0.6*a3
mean3[5]<-mean[6];mean3[6]<-mean3[4]-0.6*a3
mean3[7]<-mean3[3];mean3[8]<-mean[6]-a3;mean3[9]<-mean[3]
sigma1[1]<-sigmaB1/2;sigma2[4]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,2,1)
gs[1]<-0.00453*mean[1]+0.00302*mean[2]+0.00453*mean[3]+0.03172*
mean1[1]+0.03193*mean1[2]-0.02362*mean1[3]-0.02341*mean1[4]+
0.08686*mean2[1]+0.08749*mean2[2]-0.07918*mean2[3]-0.07855*
mean2[4]+0.08686*mean3[1]+0.08707*mean3[2]+0.0877*mean3[3]+
0.03151*mean3[4]+0.03172*mean3[5]+0.03235*mean3[6]-0.13453*
mean3[7]-0.13432*mean3[8]-0.13369*mean3[9];
gs[2]<-0.00453*mean[1]+0.00302*mean[2]+0.00453*mean[3]+0.03172*
mean1[1]-0.02362*mean1[2]+0.03193*mean1[3]-0.02341*mean1[4]+
0.08686*mean2[1]-0.07918*mean2[2]+0.08749*mean2[3]-0.07855*
mean2[4]+0.08686*mean3[1]+0.03151*mean3[2]-0.13453*mean3[3]+
0.08707*mean3[4]+0.03172*mean3[5]-0.13432*mean3[6]+0.0877*
mean3[7]+0.03235*mean3[8]-0.13369*mean3[9];
g_aa1<-0.75*gs[2]^2/n_fam
g_aa2<-0.75*gs[1]^2/n_fam
g_aa3<-0.75*(gs[1]^2+gs[2]^2)/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[4];sigma3[8]<-sigma3[2]
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,4,n_samB1); swx1 <- matrix(0,4,1)
W2 <- matrix(0,4,n_samB2); swx2 <- matrix(0,4,1)
W3 <- matrix(0,9,n_samF2); swx3 <- matrix(0,9,1)
hh<-matrix(0,15,15);b_line<-matrix(0,15,1)
n0<-matrix(0,18,1);s0<-matrix(0,18,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:4) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:4) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:9) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:4)]<-mix_pi1[c(1:4)]*n_samB1;n0[c(5:8)]<-mix_pi2[c(1:4)]*n_samB2
s0[c(1:9)]<-mix_pi3[c(1:9)]*n_samF2
s0[c(1:9)][abs(s0[c(1:9)])<0.00000001]<-0.000001
n0[c(1:8)][abs(n0[c(1:8)])<0.00000001]<-0.000001
aaa0<-0;AA<-matrix(0,15,1);n_iter<-0;aaa1<-1000
while(aaa1>0.001)
{
n_iter<-n_iter+1
gs[1]<-0.00453*mean[1]+0.00302*mean[2]+0.00453*mean[3]+0.03172*
mean1[1]+0.03193*mean1[2]-0.02362*mean1[3]-0.02341*mean1[4]+
0.08686*mean2[1]+0.08749*mean2[2]-0.07918*mean2[3]-0.07855*
mean2[4]+0.08686*mean3[1]+0.08707*mean3[2]+0.0877*mean3[3]+
0.03151*mean3[4]+0.03172*mean3[5]+0.03235*mean3[6]-0.13453*
mean3[7]-0.13432*mean3[8]-0.13369*mean3[9];
gs[2]<-0.00453*mean[1]+0.00302*mean[2]+0.00453*mean[3]+0.03172*
mean1[1]-0.02362*mean1[2]+0.03193*mean1[3]-0.02341*mean1[4]+
0.08686*mean2[1]-0.07918*mean2[2]+0.08749*mean2[3]-0.07855*
mean2[4]+0.08686*mean3[1]+0.03151*mean3[2]-0.13453*mean3[3]+
0.08707*mean3[4]+0.03172*mean3[5]-0.13432*mean3[6]+0.0877*
mean3[7]+0.03235*mean3[8]-0.13369*mean3[9];
g_aa1<-0.75*gs[2]^2/n_fam
g_aa2<-0.75*gs[1]^2/n_fam
g_aa3<-0.75*(gs[1]^2+gs[2]^2)/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma1[4]<-sigma1[1]+g_aa3;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[4];sigma3[8]<-sigma3[2]
hh[1,1]<-sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma3[1]/s0[1]+sigma3[2]/s0[2]
hh[1,2]<-0
hh[1,3]<-sigma1[1]/n0[1]+sigma3[1]/s0[1]
hh[1,4]<-0
hh[1,5]<-0
hh[1,6]<-0
hh[1,7]<--sigma1[1]/n0[1]
hh[1,8]<-0
hh[1,9]<-0
hh[1,10]<--sigma3[1]/s0[1]
hh[1,11]<-0
hh[1,12]<--sigma1[1]/n0[1]+sigma1[2]/n0[2]
hh[1,13]<--sigma3[1]/s0[1]-sigma3[2]/s0[2]
hh[1,14]<--5*sigma1[2]/n0[2]
hh[1,15]<-4*sigma3[1]/s0[1]
hh[2,2]<-sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[2,3]<-sigma1[4]/n0[4]+sigma3[5]/s0[5]
hh[2,4]<--sigma3[5]/s0[5]
hh[2,5]<-0
hh[2,6]<-hh[2,4]
hh[2,7]<-sigma1[4]/n0[4]
hh[2,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[2,9]<--4*sigma3[5]/s0[5]
hh[2,10]<-0
hh[2,11]<--2*sigma1[3]/n0[3]
hh[2,12]<--sigma1[3]/n0[3]+sigma1[4]/n0[4]
hh[2,13]<-sigma3[4]/s0[4]
hh[2,14]<--5*sigma1[3]/n0[3]
hh[2,15]<-2*sigma1[4]/n0[4]+4*sigma3[5]/s0[5]
hh[3,3]<-sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma3[1]/s0[1]+sigma3[5]/s0[5]
hh[3,4]<--sigma3[5]/s0[5]
hh[3,5]<-0
hh[3,6]<-hh[3,4]
hh[3,7]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[3,8]<--sigma1[4]/n0[4]-2*sigma3[5]/s0[5]
hh[3,9]<--4*sigma3[5]/s0[5]
hh[3,10]<--sigma3[1]/s0[1]
hh[3,11]<-0
hh[3,12]<--sigma1[1]/n0[1]+sigma1[4]/n0[4]
hh[3,13]<--sigma3[1]/s0[1]
hh[3,14]<-0
hh[3,15]<-2*sigma1[4]/n0[4]+4*sigma3[1]/s0[1]+4*sigma3[5]/s0[5]
hh[4,4]<-sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma3[5]/s0[5]+sigma3[6]/s0[6]
hh[4,5]<-0
hh[4,6]<-sigma2[1]/n0[5]+sigma3[5]/s0[5]
hh[4,7]<-sigma2[1]/n0[5]
hh[4,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[4,9]<-4*sigma3[5]/s0[5]
hh[4,10]<-0
hh[4,11]<--2*sigma2[2]/n0[6]
hh[4,12]<--sigma2[1]/n0[5]+sigma2[2]/n0[6]
hh[4,13]<-sigma3[6]/s0[6]
hh[4,14]<-3*sigma2[2]/n0[6]
hh[4,15]<-2*sigma2[1]/n0[5]-4*sigma3[5]/s0[5]
hh[5,5]<-sigma2[3]/n0[7]+sigma2[4]/n0[8]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[5,6]<-sigma2[4]/n0[8]+sigma3[9]/s0[9]
hh[5,7]<--sigma2[4]/n0[8]
hh[5,8]<-0
hh[5,9]<-0
hh[5,10]<-sigma3[9]/s0[9]
hh[5,11]<-0
hh[5,12]<--sigma2[3]/n0[7]+sigma2[4]/n0[8]
hh[5,13]<--sigma3[8]/s0[8]-sigma3[9]/s0[9]
hh[5,14]<-3*sigma2[3]/n0[7]
hh[5,15]<-0
hh[6,6]<-sigma2[1]/n0[5]+sigma2[4]/n0[8]+sigma3[5]/s0[5]+sigma3[9]/s0[9]
hh[6,7]<-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[6,8]<-sigma2[1]/n0[5]+2*sigma3[5]/s0[5]
hh[6,9]<-4*sigma3[5]/s0[5]
hh[6,10]<-sigma3[9]/s0[9]
hh[6,11]<-0
hh[6,12]<--sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[6,13]<--sigma3[9]/s0[9]
hh[6,14]<-0
hh[6,15]<-2*sigma2[1]/n0[5]-4*sigma3[5]/s0[5]
hh[7,7]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[4]/n0[8]
hh[7,8]<--sigma1[4]/n0[4]+sigma2[1]/n0[5]
hh[7,9]<-sigma*(3/n_samP1-3/n_samP2)
hh[7,10]<-0
hh[7,11]<-sigma*(1/n_samP1+1/n_samP2)
hh[7,12]<-sigma*(3/n_samP1-3/n_samP2)+sigma1[1]/n0[1]+sigma1[4]/n0[4]-sigma2[1]/n0[5]-sigma2[4]/n0[8]
hh[7,13]<-0
hh[7,14]<-0
hh[7,15]<-sigma*(1/n_samP1+1/n_samP2)+2*sigma1[4]/n0[4]+2*sigma2[1]/n0[5]
hh[8,8]<-sigma1[4]/n0[4]+sigma2[1]/n0[5]+4*sigma3[5]/s0[5]
hh[8,9]<-8*sigma3[5]/s0[5]
hh[8,10]<-0
hh[8,11]<-0
hh[8,12]<--sigma1[4]/n0[4]-sigma2[1]/n0[5]
hh[8,13]<-0
hh[8,14]<-0
hh[8,15]<--2*sigma1[4]/n0[4]+2*sigma2[1]/n0[5]-8*sigma3[5]/s0[5]
hh[9,9]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma3[3]/s0[3]+16*sigma3[5]/s0[5]+4*sigma3[7]/s0[7]
hh[9,10]<-2*sigma3[3]/s0[3]+2*sigma3[7]/s0[7]
hh[9,11]<-sigma*(3/n_samP1-3/n_samP2)+2*sigma3[3]/s0[3]-2*sigma3[7]/s0[7]
hh[9,12]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)
hh[9,13]<-0
hh[9,14]<--2*sigma3[3]/s0[3]+2*sigma3[7]/s0[7]
hh[9,15]<-sigma*(3/n_samP1-3/n_samP2)-16*sigma3[5]/s0[5]
hh[10,10]<-sigma3[1]/s0[1]+sigma3[3]/s0[3]+sigma3[7]/s0[7]+sigma3[9]/s0[9]
hh[10,11]<-sigma3[3]/s0[3]-sigma3[7]/s0[7]
hh[10,12]<-0
hh[10,13]<-sigma3[1]/s0[1]-sigma3[9]/s0[9]
hh[10,14]<--sigma3[3]/s0[3]+sigma3[7]/s0[7]
hh[10,15]<--4*sigma3[1]/s0[1]
hh[11,11]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[3]/n0[3]+4*sigma2[2]/n0[6]+sigma3[3]/s0[3]+sigma3[7]/s0[7]
hh[11,12]<-sigma*(3/n_samP1-3/n_samP2)+2*sigma1[3]/n0[3]-2*sigma2[2]/n0[6]
hh[11,13]<-0
hh[11,14]<-10*sigma1[3]/n0[3]-6*sigma2[2]/n0[6]-sigma3[3]/s0[3]-sigma3[7]/s0[7]
hh[11,15]<-sigma*(1/n_samP1+1/n_samP2)
hh[12,12]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+sigma1[1]/n0[1]+sigma1[2]/n0[2]+sigma1[3]/n0[3]+sigma1[4]/n0[4]+sigma2[1]/n0[5]+sigma2[2]/n0[6]+sigma2[3]/n0[7]+sigma2[4]/n0[8]
hh[12,13]<-0
hh[12,14]<--5*sigma1[2]/n0[2]+5*sigma1[3]/n0[3]+3*sigma2[2]/n0[6]-3*sigma2[3]/n0[7]
hh[12,15]<-sigma*(3/n_samP1-3/n_samP2)+2*sigma1[4]/n0[4]-2*sigma2[1]/n0[5]
hh[13,13]<-sigma3[1]/s0[1]+sigma3[2]/s0[2]+sigma3[4]/s0[4]+sigma3[6]/s0[6]+sigma3[8]/s0[8]+sigma3[9]/s0[9]
hh[13,14]<-0
hh[13,15]<--4*sigma3[1]/s0[1]
hh[14,14]<-25*sigma1[2]/n0[2]+25*sigma1[3]/n0[3]+9*sigma2[2]/n0[6]+9*sigma2[3]/n0[7]+sigma3[3]/s0[3]+sigma3[7]/s0[7]
hh[14,15]<-0
hh[15,15]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[4]/n0[4]+4*sigma2[1]/n0[5]+ 16*sigma3[1]/s0[1]+16*sigma3[5]/s0[5]
for(i in 2:15)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx3[1]/s0[1]+sumwx3[2]/s0[2]
b_line[2]<-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[3]<-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]-sumwx3[1]/s0[1]+sumwx3[5]/s0[5]
b_line[4]<-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
b_line[5]<-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]-sumwx3[8]/s0[8]+sumwx3[9]/s0[9]
b_line[6]<-sumwx2[1]/n0[5]-sumwx2[4]/n0[8]-sumwx3[5]/s0[5]+sumwx3[9]/s0[9]
b_line[7]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]+sumwx2[4]/n0[8]
b_line[8]<-sumwx1[4]/n0[4]+sumwx2[1]/n0[5]-2*sumwx3[5]/s0[5]
b_line[9]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-2*sumwx3[3]/s0[3]-4*sumwx3[5]/s0[5]-2*sumwx3[7]/s0[7]
b_line[10]<-sumwx3[1]/s0[1]-sumwx3[3]/s0[3]-sumwx3[7]/s0[7]+sumwx3[9]/s0[9]
b_line[11]<-sumx[1]/n_samP1-sumx[3]/n_samP2-2*sumwx1[3]/n0[3]+2*sumwx2[2]/n0[6]-sumwx3[3]/s0[3]+sumwx3[7]/s0[7]
b_line[12]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[2]/n0[2]-sumwx1[3]/n0[3]-sumwx1[4]/n0[4]-sumwx2[1]/n0[5]-sumwx2[2]/n0[6]-sumwx2[3]/n0[7]-sumwx2[4]/n0[8]
b_line[13]<-sumwx3[1]/s0[1]-sumwx3[2]/s0[2]-sumwx3[4]/s0[4]+sumwx3[6]/s0[6]+sumwx3[8]/s0[8]-sumwx3[9]/s0[9]
b_line[14]<-5*sumwx1[2]/n0[2]-5*sumwx1[3]/n0[3]-3*sumwx2[2]/n0[6]+3*sumwx2[3]/n0[7]+sumwx3[3]/s0[3]-sumwx3[7]/s0[7]
b_line[15]<-sumx[1]/n_samP1-sumx[3]/n_samP2-2*sumwx1[4]/n0[4]+2*sumwx2[1]/n0[5]-4*sumwx3[1]/s0[1]+4*sumwx3[5]/s0[5]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]+sigma*(-B[7]-3*B[9]-B[11]-3*B[12]-B[15]))/n_samP1
mean[2]<-(sumx[2]+sigma*(-2*B[9]-2*B[12]))/n_samF1
mean[3]<-(sumx[3]+sigma*(B[7]-3*B[9]+B[11]-3*B[12]+B[15]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(-B[1]-B[3]+B[7]+B[12]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(B[1]+B[12]-5*B[14]))/n0[2]
mean1[3]<-(sumwx1[3]+sigma1[3]*(-B[2]+2*B[11]+B[12]+5*B[14]))/n0[3]
mean1[4]<-(sumwx1[4]+sigma1[4]*(B[2]+B[3]+B[7]-B[8]+B[12]+2*B[15]))/n0[4]
mean2[1]<-(sumwx2[1]+sigma2[1]*(-B[4]-B[6]-B[7]-B[8]+B[12]-2*B[15]))/n0[5]
mean2[2]<-(sumwx2[2]+sigma2[2]*(B[4]-2*B[11]+B[12]+3*B[14]))/n0[6]
mean2[3]<-(sumwx2[3]+sigma2[3]*(-B[5]+B[12]-3*B[14]))/n0[7]
mean2[4]<-(sumwx2[4]+sigma2[4]*(B[5]+B[6]-B[7]+B[12]))/n0[8]
mean3[1]<-(sumwx3[1]+sigma3[1]*(B[1]+B[3]-B[10]-B[13]+4*B[15]))/s0[1]
mean3[2]<-(sumwx3[2]+sigma3[2]*(-B[1]+B[13]))/s0[2]
mean3[3]<-(sumwx3[3]+sigma3[3]*(2*B[9]+B[10]+B[11]-B[14]))/s0[3]
mean3[7]<-(sumwx3[7]+sigma3[7]*(2*B[9]+B[10]-B[11]+B[14]))/s0[7]
mean3[4]<-(sumwx3[4]+sigma3[4]*(B[2]+B[13]))/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-B[2]-B[3]+B[4]+B[6]+2*B[8]+4*B[9]-4*B[15]))/s0[5]
mean3[6]<-(sumwx3[6]+sigma3[6]*(-B[4]-B[13]))/s0[6]
mean3[8]<-(sumwx3[8]+sigma3[8]*(B[5]-B[13]))/s0[8]
mean3[9]<-(sumwx3[9]+sigma3[9]*(-B[5]-B[6]-B[10]+B[13]))/s0[9]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:4) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:4) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 }; for(i in 1:9) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
aa4<-sigma1[1]/(sigma1[1]+g_aa3)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2+swx1[4]*aa4^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]+aa4*n0[4]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
aaa0<-sigma2[4];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma2[4]/(sigma2[4]+g_aa3)
aa2<-sigma2[4]/(sigma2[4]+g_aa2)
aa3<-sigma2[4]/(sigma2[4]+g_aa1)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]*aa3^2+swx2[4]
as4<-aa1*n0[5]+aa2*n0[6]+aa3*n0[7]+n0[8]
sigma2[4]<-as3/as4
aaa1<-abs(sigma2[4]-aaa0)
aaa0<-sigma2[4]
if (n_iter>20) break
}
sigma50<-sigma2[4]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[4]<-sigma}
sigma2[4]<-sigma50+sigma;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
aaa0<-sigma3[1]
aa6<-swx3[1]+swx3[3]+swx3[7]+swx3[9];aa7<-s0[1]+s0[3]+s0[7]+s0[9]
n_iter<-0
aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
aa3<-sigma3[1]/(sigma3[1]+g_aa3)
as5<-aa6+(swx3[2]+swx3[8])*aa1^2+(swx3[4]+swx3[6])*aa2^2+swx3[5]*aa3^2
as6<-aa7+aa1*(s0[2]+s0[8])+aa2*(s0[4]+s0[6])+aa3*s0[5]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma60+sigma;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa3
sigma3[6]<-sigma3[4];sigma3[8]<-sigma3[2]
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
n0[14]<-sigma/(sigma+sigma40+g_aa3)
s0[11]<-sigma/(sigma+sigma50+g_aa3)
s0[12]<-sigma/(sigma+sigma50+g_aa2)
s0[13]<-sigma/(sigma+sigma50+g_aa1)
s0[14]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:4)]*n0[c(11:14)]^2+swx2[c(1:4)]*s0[c(11:14)]^2)
ab4<-sum(n0[c(1:4)]*n0[c(11:14)]+n0[c(5:8)]*s0[c(11:14)])
n0[11]<-sigma/(sigma+sigma60);n0[13]<-n0[17]<-n0[19]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1);n0[18]<-n0[12]
n0[14]<-sigma/(sigma+sigma60+g_aa2);n0[16]<-n0[14]
n0[15]<-sigma/(sigma+sigma60+g_aa3)
ab3<-ab3+sum(swx3[c(1:9)]*n0[c(11:19)]^2)
ab4<-ab4+sum(s0[c(1:9)]*n0[11:19])
sigma<-(ab1+ab3)/(ab2+ab4);aaa1<-abs(sigma-aaa0);aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1
sigma1[3]<-sigma1[1]+g_aa2;sigma1[4]<-sigma1[1]+g_aa3
sigma2[4]<-sigma+sigma50;sigma2[1]<-sigma2[4]+g_aa3
sigma2[2]<-sigma2[4]+g_aa2;sigma2[3]<-sigma2[4]+g_aa1
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[7]<-sigma3[9]<-sigma3[1]
sigma3[2]<-sigma3[1]+g_aa1;sigma3[8]<-sigma3[2]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[6]<-sigma3[4]
sigma3[5]<-sigma3[1]+g_aa3
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*9
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,4)
for(i in 1:4){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,4)
for(i in 1:4){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,9)
for(i in 1:9){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,1,1,1,0,1,1,1,0,1,1,-1,-1,-1,0,1,1,1,0.5,0.25,1,1,0.5,0.5,0.25,1,0.5,1,0.5,
0.25,1,0.5,0.5,0.5,0.25,1,0.5,0.5,-0.5,0.25,1,0.5,-1,-0.5,0.25,1,-1,0.5,-0.5,
0.25,1,-1,-1,-0.5,0.25,1,1,1,0,0.25,1,1,0.5,0,0.25,1,1,-1,0,0.25,1,0.5,1,0,0.25,
1,0.5,0.5,0,0.25,1,0.5,-1,0,0.25,1,-1,1,0,0.25,1,-1,0.5,0,0.25,1,-1,-1,0,0.25),20,5,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean1[4],mean2[1],mean2[2],mean2[3],mean2[4],
mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6],mean3[7],mean3[8],mean3[9]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[4]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[4]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-CD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4),round(t(sigma1),4),
round(t(mix_pi1),4),round(t(mean2),4),round(t(sigma2),4),round(t(mix_pi2),4),
round(t(mean3),4),round(t(sigma3),4),round(t(mix_pi3),4),
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[3],4),round(B1[2],4),round(B1[3],4)," "," "," "," ",round(B1[4],4),round(B1[5],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
G6FModelFun[[24]] <- function(K1,logL,df11,df21,df31,df41,df51,df61,G6Ftext2){
dataP1 <- as.matrix(as.numeric(df11[,1]));dataF1 <- as.matrix(as.numeric(df21[,1]))
dataP2 <- as.matrix(as.numeric(df31[,1]));dataB1 <- as.matrix(as.numeric(df41[,1]))
dataB2 <- as.matrix(as.numeric(df51[,1]));dataF2 <- as.matrix(as.numeric(df61[,1]))
n_samP1<-dim(dataP1)[1];n_samF1<-dim(dataF1)[1];n_samP2<-dim(dataP2)[1]
n_samB1<-dim(dataB1)[1];n_samB2<-dim(dataB2)[1];n_samF2<-dim(dataF2)[1]
sumx<-as.matrix(c(sum(dataP1),sum(dataF1),sum(dataP2),sum(dataB1),sum(dataB2),sum(dataF2)))
s<-as.matrix(c(sum(dataP1^2),sum(dataF1^2),sum(dataP2^2),sum(dataB1^2),sum(dataB2^2),sum(dataF2^2)))
ss<-matrix(0,3,1);ss[1]<-s[1]-sumx[1]^2/n_samP1;ss[2]<-s[2]-sumx[2]^2/n_samF1;ss[3]<-s[3]-sumx[3]^2/n_samP2
mean<-as.matrix(c(mean(dataP1),mean(dataF1),mean(dataP2),mean(dataB1),mean(dataB2),mean(dataF2)))
sigma0<-sum(ss)/(n_samP1+n_samF1+n_samP2-3)
sigmaB1<-var(dataB1);sigma40<-sigmaB1
sigmaB2<-var(dataB2);sigma50<-sigmaB2
sigmaF2<-var(dataF2);sigma60<-sigmaF2
sigmaP1<-sigmaF1<-sigmaP2<-sigma0
m_esp <- 0.0001;n_fam <- as.numeric(G6Ftext2)
mi1<-as.matrix(c(0.25,0.5,0.25));sigma1<-matrix(0,3,1)
mi2<-as.matrix(c(0.25,0.5,0.25));sigma2<-matrix(0,3,1)
mi3<-as.matrix(c(0.0625,0.25,0.125,0.25,0.25,0.0625))
sigma3<-matrix(0,6,1);sigma<-sigma0
a1<-sqrt(sigmaB1/n_samB1);if (mean[1]<mean[3]) {a1<--a1}
mean1<-as.matrix(c(mean[1],mean[4],mean[4]-a1))
a2<-sqrt(sigmaB2/n_samB2);if (mean[1]<mean[3]) {a2<--a2}
mean2<-as.matrix(c(mean1[3],mean[5],mean[5]-a2))
a3<-sqrt(sigmaF2/n_samF2);if (mean[1]<mean[3]){a3<--a3}
mean3<-as.matrix(c(mean[6]+2.5*a3,mean[6]+1.5*a3,mean[6]+0.2*a3,mean[6]+a3,mean[6]-0.5*a3,mean[6]-2.5*a3))
sigma1[1]<-sigmaB1/2;sigma2[3]<-sigmaB2/2;sigma3[1]<-sigmaF2/2
gs<-matrix(0,1,1)
gs[1]<-0.00459*mean[1]+0.00306*mean[2]+0.00459*mean[3]+0.03559*mean1[1]+
0.00421*mean1[2]-0.02717*mean1[3]+0.09835*mean2[1]+0.00421*mean2[2]-
0.08993*mean2[3]+0.09835*mean3[1]+0.06697*mean3[2]-0.02717*mean3[3]+
0.03559*mean3[4]-0.05855*mean3[5]-0.15270*mean3[6]
g_aa1<-0.75*gs[1]^2/n_fam
g_aa2<-1.5*gs[1]^2/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[6]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa1
L0<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma0))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma0))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma0))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mi3)))
iteration <- 0; stopa <- 1000
W1 <- matrix(0,3,n_samB1); swx1 <- matrix(0,3,1)
W2 <- matrix(0,3,n_samB2); swx2 <- matrix(0,3,1)
W3 <- matrix(0,6,n_samF2); swx3 <- matrix(0,6,1)
hh<-matrix(0,11,11);b_line<-matrix(0,11,1)
n0<-matrix(0,15,1);s0<-matrix(0,15,1)
while(stopa > m_esp&&iteration<=1000){
iteration <- iteration + 1
for(i in 1:3) { W1[i,] <- mi1[i]*dnorm(dataB1,mean1[i],sqrt(sigma1[i]))/dmixnorm(dataB1,mean1,sqrt(sigma1),mi1) }
mix_pi1 <- as.matrix(rowSums(W1)/n_samB1)
sumwx1 <- W1%*%dataB1
for(i in 1:3) { W2[i,] <- mi2[i]*dnorm(dataB2,mean2[i],sqrt(sigma2[i]))/dmixnorm(dataB2,mean2,sqrt(sigma2),mi2) }
mix_pi2 <- as.matrix(rowSums(W2)/n_samB2)
sumwx2 <- W2%*%dataB2
for(i in 1:6) { W3[i,] <- mi3[i]*dnorm(dataF2,mean3[i],sqrt(sigma3[i]))/dmixnorm(dataF2,mean3,sqrt(sigma3),mi3) }
mix_pi3 <- as.matrix(rowSums(W3)/n_samF2)
sumwx3 <- W3%*%dataF2
n0[c(1:3)]<-mix_pi1[c(1:3)]*n_samB1;n0[c(4:6)]<-mix_pi2[c(1:3)]*n_samB2
s0[c(1:6)]<-mix_pi3[c(1:6)]*n_samF2
s0[c(1:6)][abs(s0[c(1:6)])<0.00000001]<-0.000001
n0[c(1:6)][abs(n0[c(1:6)])<0.00000001]<-0.000001
aaa0<-0;AA<-matrix(0,11,1);n_iter<-0;aaa1<-1000
while(aaa1>0.001)
{
n_iter<-n_iter+1;
gs[1]<-0.00459*mean[1]+0.00306*mean[2]+0.00459*mean[3]+0.03559*mean1[1]+
0.00421*mean1[2]-0.02717*mean1[3]+0.09835*mean2[1]+0.00421*mean2[2]-
0.08993*mean2[3]+0.09835*mean3[1]+0.06697*mean3[2]-0.02717*mean3[3]+
0.03559*mean3[4]-0.05855*mean3[5]-0.15270*mean3[6]
g_aa1<-0.75*gs[1]*gs[1]/n_fam
g_aa2<-1.5*gs[1]*gs[1]/n_fam
sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[2]<-sigma3[1]+g_aa1;sigma3[3]<-sigma3[6]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2;sigma3[5]<-sigma3[1]+g_aa1
hh[1,1]<-sigma*(1/n_samP1+1/n_samF1+4/n_samP2)+sigma1[3]/n0[3]+sigma2[1]/n0[4]+4*sigma3[1]/s0[1]+4*sigma3[6]/s0[6]
hh[1,2]<-sigma*(3/n_samP1+2/n_samF1+6/n_samP2)
hh[1,3]<-sigma*(1/n_samP1-2/n_samP2)+4*sigma3[6]/s0[6]
hh[1,4]<-sigma*(1/n_samP1-2/n_samP2)-sigma1[3]/n0[3]-sigma2[1]/n0[4]
hh[1,5]<-sigma1[3]/n0[3]
hh[1,6]<--6*sigma3[1]/s0[1]
hh[1,7]<-2*sigma3[1]/s0[1]+2*sigma3[6]/s0[6]
hh[1,8]<-0
hh[1,9]<-sigma1[3]/n0[3]-sigma2[1]/n0[4]
hh[1,10]<-0
hh[1,11]<--2*sigma3[6]/s0[6]
hh[2,2]<-sigma*(9/n_samP1+4/n_samF1+9/n_samP2)+4*sigma1[1]/n0[1]+4*sigma2[3]/n0[6]+16*sigma3[4]/s0[4]
hh[2,3]<-sigma*(3/n_samP1-3/n_samP2)-4*sigma1[1]/n0[1]
hh[2,4]<-sigma*(3/n_samP1-3/n_samP2)+2*sigma1[1]/n0[1]-2*sigma2[3]/n0[6]
hh[2,5]<--2*sigma1[1]/n0[1]
hh[2,6]<-4*sigma3[4]/s0[4]
hh[2,7]<--2*sigma1[1]/n0[1]-2*sigma2[3]/n0[6]
hh[2,8]<-0
hh[2,9]<-8*sigma3[4]/s0[4]
hh[2,10]<-4*sigma3[4]/s0[4]
hh[2,11]<--4*sigma3[4]/s0[4]
hh[3,3]<-sigma*(1/n_samP1+1/n_samP2)+4*sigma1[1]/n0[1]+4*sigma3[6]/s0[6]+36*sigma3[5]/s0[5]+36*sigma1[2]/n0[2]
hh[3,4]<-sigma*(1/n_samP1-1/n_samP2)-2*sigma1[1]/n0[1]
hh[3,5]<-2*sigma1[1]/n0[1]+12*sigma1[2]/n0[2]
hh[3,6]<-6*sigma3[5]/s0[5]
hh[3,7]<-2*sigma1[1]/n0[1]+2*sigma3[6]/s0[6]
hh[3,8]<--6*sigma1[2]/n0[2]-6*sigma3[5]/s0[5]
hh[3,9]<-0
hh[3,10]<-6*sigma3[5]/s0[5]
hh[3,11]<--2*sigma3[6]/s0[6]-12*sigma3[5]/s0[5]
hh[4,4]<-sigma*(1/n_samP1+1/n_samP2)+sigma1[1]/n0[1]+sigma1[3]/n0[3]+sigma2[1]/n0[4]+sigma2[3]/n0[6]
hh[4,5]<--sigma1[1]/n0[1]-sigma1[3]/n0[3]
hh[4,6]<-0
hh[4,7]<--sigma1[1]/n0[1]+sigma2[3]/n0[6]
hh[4,8]<-0
hh[4,9]<--sigma1[3]/n0[3]+sigma2[1]/n0[4]
hh[4,10]<-0
hh[4,11]<-0
hh[5,5]<-sigma1[1]/n0[1]+4*sigma1[2]/n0[2]+sigma1[3]/n0[3]
hh[5,6]<-0
hh[5,7]<-sigma1[1]/n0[1]
hh[5,8]<--2*sigma1[2]/n0[2]
hh[5,9]<-sigma1[3]/n0[3]
hh[5,10]<-0
hh[5,11]<-0
hh[6,6]<-9*sigma3[1]/s0[1]+9*sigma3[2]/s0[2]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[6,7]<--3*sigma3[1]/s0[1]
hh[6,8]<-3*sigma3[2]/s0[2]-sigma3[5]/s0[5]
hh[6,9]<-2*sigma3[4]/s0[4]
hh[6,10]<--3*sigma3[2]/s0[2]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[6,11]<--sigma3[4]/s0[4]-2*sigma3[5]/s0[5]
hh[7,7]<-sigma1[1]/n0[1]+sigma2[3]/n0[6]+sigma3[1]/s0[1]+sigma3[6]/s0[6]
hh[7,8]<-0
hh[7,9]<-0
hh[7,10]<-0
hh[7,11]<--sigma3[6]/s0[6]
hh[8,8]<-sigma1[2]/n0[2]+sigma2[2]/n0[5]+sigma3[2]/s0[2]+sigma3[5]/s0[5]
hh[8,9]<-0
hh[8,10]<--sigma3[2]/s0[2]-sigma3[5]/s0[5]
hh[8,11]<-2*sigma3[5]/s0[5]
hh[9,9]<-sigma1[3]/n0[3]+sigma2[1]/n0[4]+4*sigma3[4]/s0[4]
hh[9,10]<-2*sigma3[4]/s0[4]
hh[9,11]<--2*sigma3[4]/s0[4]
hh[10,10]<-sigma3[2]/s0[2]+sigma3[3]/s0[3]+sigma3[4]/s0[4]+sigma3[5]/s0[5]
hh[10,11]<--sigma3[4]/s0[4]-2*sigma3[5]/s0[5]
hh[11,11]<-sigma3[4]/s0[4]+sigma3[6]/s0[6]+4*sigma3[5]/s0[5]
for(i in 2:11)
{
for(j in 1:(i-1))
{
hh[i,j]<-hh[j,i]
}
}
b_line[1]<-sumx[1]/n_samP1+sumx[2]/n_samF1+2*sumx[3]/n_samP2+sumwx1[3]/n0[3]-sumwx2[1]/n0[4]-2*sumwx3[1]/s0[1]-2*sumwx3[6]/s0[6]
b_line[2]<-3*sumx[1]/n_samP1+2*sumx[2]/n_samF1+3*sumx[3]/n_samP2-2*sumwx1[1]/n0[1]-2*sumwx2[3]/n0[6]-4*sumwx3[4]/s0[4]
b_line[3]<-sumx[1]/n_samP1-sumx[3]/n_samP2+2*sumwx1[1]/n0[1]-2*sumwx3[6]/s0[6]+6*sumwx3[5]/s0[5]-6*sumwx1[2]/n0[2]
b_line[4]<-sumx[1]/n_samP1-sumx[3]/n_samP2-sumwx1[1]/n0[1]-sumwx1[3]/n0[3]+sumwx2[1]/n0[4]+sumwx2[3]/n0[6]
b_line[5]<-sumwx1[1]/n0[1]-2*sumwx1[2]/n0[2]+sumwx1[3]/n0[3]
b_line[6]<-3*sumwx3[1]/s0[1]-3*sumwx3[2]/s0[2]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[7]<-sumwx1[1]/n0[1]+sumwx2[3]/n0[6]-sumwx3[1]/s0[1]-sumwx3[6]/s0[6]
b_line[8]<-sumwx1[2]/n0[2]+sumwx2[2]/n0[5]-sumwx3[2]/s0[2]-sumwx3[5]/s0[5]
b_line[9]<-sumwx1[3]/n0[3]+sumwx2[1]/n0[4]-2*sumwx3[4]/s0[4]
b_line[10]<-sumwx3[2]/s0[2]-sumwx3[3]/s0[3]-sumwx3[4]/s0[4]+sumwx3[5]/s0[5]
b_line[11]<-sumwx3[4]/s0[4]-2*sumwx3[5]/s0[5]+sumwx3[6]/s0[6]
B<-solve(hh,b_line)
mean[1]<-(sumx[1]-sigma*(B[1]+3*B[2]+B[3]+B[4]))/n_samP1
mean[2]<-(sumx[2]-sigma*(B[1]+2*B[2]))/n_samF1
mean[3]<-(sumx[3]-sigma*(2*B[1]+3*B[2]-B[3]-B[4]))/n_samP2
mean1[1]<-(sumwx1[1]+sigma1[1]*(2*B[2]-2*B[3]+B[4]-B[5]-B[7]))/n0[1]
mean1[2]<-(sumwx1[2]+sigma1[2]*(6*B[3]+2*B[5]-B[8]))/n0[2]
mean1[3]<-(sumwx1[3]+sigma1[3]*(-B[1]+B[4]-B[5]-B[9]))/n0[3]
mean2[1]<-(sumwx2[1]+sigma2[1]*(B[1]-B[4]-B[9]))/n0[4]
mean2[2]<-(sumwx2[2]+sigma2[2]*(-B[8]))/n0[5]
mean2[3]<-(sumwx2[3]+sigma2[3]*(2*B[2]-B[4]-B[7]))/n0[6]
mean3[1]<-(sumwx3[1]+sigma3[1]*(2*B[1]-3*B[6]+B[7]))/s0[1]
mean3[2]<-(sumwx3[2]+sigma3[2]*(3*B[6]+B[8]-B[10]))/s0[2]
mean3[3]<-(sumwx3[3]+sigma3[3]*B[10])/s0[3]
mean3[4]<-(sumwx3[4]+sigma3[4]*(4*B[2]+B[6]+2*B[9]+B[10]-B[11]))/s0[4]
mean3[5]<-(sumwx3[5]+sigma3[5]*(-6*B[3]-B[6]+B[8]-B[10]+2*B[11]))/s0[5]
mean3[6]<-(sumwx3[6]+sigma3[6]*(2*B[1]+2*B[3]+B[7]-B[11]))/s0[6]
aaa1<-max(abs(B-AA))
AA<-B
if (n_iter>20) break
}
ss1<-sum((dataP1-mean[1])^2);ss3<-sum((dataP2-mean[3])^2);ss2<-sum((dataF1-mean[2])^2)
for(i in 1:3) {swx1[i] <- W1[i,]%*%(dataB1-mean1[i])^2 };for(i in 1:3) {swx2[i] <- W2[i,]%*%(dataB2-mean2[i])^2 };for(i in 1:6) {swx3[i] <- W3[i,]%*%(dataF2-mean3[i])^2 }
aaa0<-sigma1[1];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa2<-sigma1[1]/(sigma1[1]+g_aa1)
aa3<-sigma1[1]/(sigma1[1]+g_aa2)
as1<-swx1[1]+swx1[2]*aa2^2+swx1[3]*aa3^2
as2<-n0[1]+aa2*n0[2]+aa3*n0[3]
sigma1[1]<-as1/as2
aaa1<-abs(sigma1[1]-aaa0)
aaa0<-sigma1[1]
if (n_iter>20) break
}
sigma40<-sigma1[1]-sigma;
if (sigma40<0) {sigma40<-0;sigma1[1]<-sigma}
sigma1[1]<-sigma40+sigma;sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
aaa0<-sigma2[3];n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma2[3]/(sigma2[3]+g_aa2)
aa2<-sigma2[3]/(sigma2[3]+g_aa1)
as3<-swx2[1]*aa1^2+swx2[2]*aa2^2+swx2[3]
as4<-aa1*n0[4]+aa2*n0[5]+n0[6]
sigma2[3]<-as3/as4
aaa1<-abs(sigma2[3]-aaa0)
aaa0<-sigma2[3]
if (n_iter>20) break
}
sigma50<-sigma2[3]-sigma;
if (sigma50<0) {sigma50<-0;sigma2[3]<-sigma}
sigma2[3]<-sigma+sigma50;sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
aaa0<-sigma3[1];aa6<-swx3[1]+swx3[3]+swx3[6];aa7<-s0[1]+s0[3]+s0[6]
n_iter<-0;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
aa1<-sigma3[1]/(sigma3[1]+g_aa1)
aa2<-sigma3[1]/(sigma3[1]+g_aa2)
as5<-aa6+(swx3[2]+swx3[5])*aa1^2+swx3[4]*aa2^2
as6<-aa7+aa1*(s0[2]+s0[5])+aa2*s0[4]
sigma3[1]<-as5/as6
aaa1<-abs(sigma3[1]-aaa0)
aaa0<-sigma3[1]
if (n_iter>20) break
}
sigma60<-sigma3[1]-sigma;
if (sigma60<0) {sigma60<-0;sigma3[1]<-sigma}
sigma3[1]<-sigma+sigma60;sigma3[2]<-sigma3[1]+g_aa1
sigma3[3]<-sigma3[6]<-sigma3[1]
sigma3[4]<-sigma3[1]+g_aa2
sigma3[5]<-sigma3[2]
ab1<-ss1+ss2+ss3;ab2<-n_samP1+n_samF1+n_samP2
n_iter<-0;aaa0<-sigma;aaa1<-1000
while (aaa1>0.0001)
{
n_iter<-n_iter+1
n0[11]<-sigma/(sigma+sigma40)
n0[12]<-sigma/(sigma+sigma40+g_aa1)
n0[13]<-sigma/(sigma+sigma40+g_aa2)
s0[11]<-sigma/(sigma+sigma50+g_aa2)
s0[12]<-sigma/(sigma+sigma50+g_aa1)
s0[13]<-sigma/(sigma+sigma50)
ab3<-sum(swx1[c(1:3)]*n0[c(11:13)]^2+swx2[c(1:3)]*s0[c(11:13)]^2)
ab4<-sum(n0[c(1:3)]*n0[c(11:13)]+n0[c(4:6)]*s0[c(11:13)])
n0[11]<-sigma/(sigma+sigma60)
n0[13]<-n0[16]<-n0[11]
n0[12]<-sigma/(sigma+sigma60+g_aa1)
n0[14]<-sigma/(sigma+sigma60+g_aa2)
n0[15]<-n0[12]
ab3<-ab3+sum(swx3[c(1:6)]*n0[c(11:16)]^2)
ab4<-ab4+sum(s0[c(1:6)]*n0[11:16])
sigma<-(ab1+ab3)/(ab2+ab4)
aaa1<-abs(sigma-aaa0)
aaa0<-sigma
if (n_iter>20) break
}
sigma1[1]<-sigma+sigma40;sigma1[2]<-sigma1[1]+g_aa1;sigma1[3]<-sigma1[1]+g_aa2
sigma2[3]<-sigma+sigma50;sigma2[1]<-sigma2[3]+g_aa2;sigma2[2]<-sigma2[3]+g_aa1
sigma3[1]<-sigma+sigma60;sigma3[3]<-sigma3[6]<-sigma3[1];sigma3[2]<-sigma3[1]+g_aa1
sigma3[5]<-sigma3[2];sigma3[4]<-sigma3[1]+g_aa2
L1<-sum(log(dnorm(dataP1,mean[1],sqrt(sigma))))+sum(log(dnorm(dataF1,mean[2],sqrt(sigma))))+
sum(log(dnorm(dataP2,mean[3],sqrt(sigma))))+sum(log(dmixnorm(dataB1,mean1,sqrt(sigma1),mix_pi1)))+
sum(log(dmixnorm(dataB2,mean2,sqrt(sigma2),mix_pi2)))+sum(log(dmixnorm(dataF2,mean3,sqrt(sigma3),mix_pi3)))
stopa <- L1 - L0
L0 <- L1
if(stopa < 0) {stopa <- -stopa}
}
abc<-L0
AIC<--2*abc+2*8
meanP1<-mean[1];meanF1<-mean[2];meanP2<-mean[3]
sigma0<-sigma
dataP1<-sort(dataP1)
P1w1<-1/(12*n_samP1)
P1bmw <- matrix(0,n_samP1,1)
P1gg <- (dataP1 - mean[1])/sqrt(as.vector(sigma))
P1bmw[which(P1gg>=0)] <- pnorm(P1gg[P1gg>=0])
P1bmw[which(P1gg<0)] <- 1 - pnorm(abs(P1gg[P1gg<0]))
nn <- dim(as.matrix(unique(P1bmw)))[1]
if(nn < n_samP1){P1bmw <- P1bmw+runif(n_samP1)/1e4}
P1dd<-c((sum(P1bmw)),(sum(P1bmw^2)),sum((P1bmw-0.5)^2))
P1w<-P1w1+sum((P1bmw - (as.matrix(c(1:n_samP1)) - 0.5)/n_samP1)^2)
P1u<- as.matrix(c(12*n_samP1*((P1dd[1]/n_samP1-0.5)^2),((45*n_samP1)/4)*((P1dd[2]/n_samP1-1/3)^2),180*n_samP1*((P1dd[3]/n_samP1-1/12)^2)))
P1D<-as.numeric(ks.test(P1bmw,"punif")[[1]][1])
P1tt <- as.matrix(c((1 - pchisq(P1u[1],1)),(1 - pchisq(P1u[2],1)),(1 - pchisq(P1u[3],1)),K1(P1w),(1-pkolm(P1D,n_samP1))))
P1tt[which( P1tt>=10e-4)]<-round(P1tt[which(P1tt>=10e-4)],4);P1tt[which(P1tt<10e-4)]<-format(P1tt[which(P1tt<10e-4)],scientific=TRUE,digit=4)
dataF1<-sort(dataF1)
F1w1<-1/(12*n_samF1)
F1bmw <- matrix(0,n_samF1,1)
F1gg <- (dataF1 - mean[2])/sqrt(as.vector(sigma))
F1bmw[which(F1gg>=0)] <- pnorm(F1gg[F1gg>=0])
F1bmw[which(F1gg<0)] <- 1 - pnorm(abs(F1gg[F1gg<0]))
nn <- dim(as.matrix(unique(F1bmw)))[1]
if(nn < n_samF1){F1bmw <- F1bmw+runif(n_samF1)/1e4}
F1dd<-c((sum(F1bmw)),(sum(F1bmw^2)),sum((F1bmw-0.5)^2))
F1w<-F1w1+sum((F1bmw - (as.matrix(c(1:n_samF1)) - 0.5)/n_samF1)^2)
F1u<- as.matrix(c(12*n_samF1*((F1dd[1]/n_samF1-0.5)^2),((45*n_samF1)/4)*((F1dd[2]/n_samF1-1/3)^2),180*n_samF1*((F1dd[3]/n_samF1-1/12)^2)))
F1D<-as.numeric(ks.test(F1bmw,"punif")[[1]][1])
F1tt <- as.matrix(c((1 - pchisq(F1u[1],1)),(1 - pchisq(F1u[2],1)),(1 - pchisq(F1u[3],1)),K1(F1w),(1-pkolm(F1D,n_samF1))))
F1tt[which(F1tt>=10e-4)]<-round(F1tt[which(F1tt>=10e-4)],4);F1tt[which(F1tt<10e-4)]<-format(F1tt[which(F1tt<10e-4)],scientific=TRUE,digit=4)
dataP2<-sort(dataP2)
P2w1<-1/(12*n_samP2)
P2bmw <- matrix(0,n_samP2,1)
P2gg <- (dataP2 - mean[3])/sqrt(as.vector(sigma))
P2bmw[which(P2gg>=0)] <- pnorm(P2gg[P2gg>=0])
P2bmw[which(P2gg<0)] <- 1 - pnorm(abs(P2gg[P2gg<0]))
nn <- dim(as.matrix(unique(P2bmw)))[1]
if(nn < n_samP2){P2bmw <- P2bmw+runif(n_samP2)/1e4}
P2dd<-c((sum(P2bmw)),(sum(P2bmw^2)),sum((P2bmw-0.5)^2))
P2w<-P2w1+sum((P2bmw - (as.matrix(c(1:n_samP2)) - 0.5)/n_samP2)^2)
P2u<- as.matrix(c(12*n_samP2*((P2dd[1]/n_samP2-0.5)^2),((45*n_samP2)/4)*((P2dd[2]/n_samP2-1/3)^2),180*n_samP2*((P2dd[3]/n_samP2-1/12)^2)))
P2D<-as.numeric(ks.test(P2bmw,"punif")[[1]][1])
P2tt <- as.matrix(c((1 - pchisq(P2u[1],1)),(1 - pchisq(P2u[2],1)),(1 - pchisq(P2u[3],1)),K1(P2w),(1-pkolm(P2D,n_samP2))))
P2tt[which(P2tt>=10e-4)]<-round(P2tt[which(P2tt>=10e-4)],4);P2tt[which(P2tt<10e-4)]<-format(P2tt[which(P2tt<10e-4)],scientific=TRUE,digit=4)
dataB1 <- sort(dataB1);
B1w1<-1/(12*n_samB1)
B1bmw <- matrix(0,n_samB1,1); B1bmwsl <- matrix(0,n_samB1,3)
for(i in 1:3){
B1gg <- (dataB1 - mean1[i])/sqrt(sigma1[i])
B1bmw[which(B1gg>=0)] <- pnorm(B1gg[B1gg>=0])
B1bmw[which(B1gg<0)] <- 1 - pnorm(abs(B1gg[B1gg<0]))
B1bmwsl[,i] <- B1bmw*mix_pi1[i]
}
B1P2 <- rowSums(B1bmwsl)
nn <- dim(as.matrix(unique(B1P2)))[1]
if(nn < n_samB1){B1P2 <- B1P2+runif(n_samB1)/1e4}
B1dd <- as.matrix(c(sum(B1P2),sum(B1P2^2),sum((B1P2-0.5)^2)))
B1WW2 <- 1/(12*n_samB1) + sum((B1P2 - (as.matrix(c(1:n_samB1)) - 0.5)/n_samB1)^2)
B1u <- as.matrix(c(12*n_samB1*((B1dd[1]/n_samB1-0.5)^2),((45*n_samB1)/4)*((B1dd[2]/n_samB1-1/3)^2),180*n_samB1*((B1dd[3]/n_samB1-1/12)^2)))
B1D <- as.numeric(ks.test(B1P2,"punif")[[1]][1])
B1tt <- as.matrix(c((1 - pchisq(B1u[1],1)),(1 - pchisq(B1u[2],1)),(1 - pchisq(B1u[3],1)),K1(B1WW2),(1-pkolm(B1D,n_samB1))))
B1tt[which( B1tt>=10e-4)]<-round(B1tt[which(B1tt>=10e-4)],4);B1tt[which(B1tt<10e-4)]<-format(B1tt[which(B1tt<10e-4)],scientific=TRUE,digit=4)
dataB2 <- sort(dataB2);
B2w1<-1/(12*n_samB2)
B2bmw <- matrix(0,n_samB2,1); B2bmwsl <- matrix(0,n_samB2,3)
for(i in 1:3){
B2gg <- (dataB2 - mean2[i])/sqrt(sigma2[i])
B2bmw[which(B2gg>=0)] <- pnorm(B2gg[B2gg>=0])
B2bmw[which(B2gg<0)] <- 1 - pnorm(abs(B2gg[B2gg<0]))
B2bmwsl[,i] <- B2bmw*mix_pi2[i]
}
B2P2 <- rowSums(B2bmwsl)
nn <- dim(as.matrix(unique(B2P2)))[1]
if(nn < n_samB2){B2P2 <- B2P2+runif(n_samB2)/1e4}
B2dd <- as.matrix(c(sum(B2P2),sum(B2P2^2),sum((B2P2-0.5)^2)))
B2WW2 <- 1/(12*n_samB2) + sum((B2P2 - (as.matrix(c(1:n_samB2)) - 0.5)/n_samB2)^2)
B2u <- as.matrix(c(12*n_samB2*((B2dd[1]/n_samB2-0.5)^2),((45*n_samB2)/4)*((B2dd[2]/n_samB2-1/3)^2),180*n_samB2*((B2dd[3]/n_samB2-1/12)^2)))
B2D <- as.numeric(ks.test(B2P2,"punif")[[1]][1])
B2tt <- as.matrix(c((1 - pchisq(B2u[1],1)),(1 - pchisq(B2u[2],1)),(1 - pchisq(B2u[3],1)),K1(B2WW2),(1-pkolm(B2D,n_samB2))))
B2tt[which( B2tt>=10e-4)]<-round(B2tt[which(B2tt>=10e-4)],4);B2tt[which(B2tt<10e-4)]<-format(B2tt[which(B2tt<10e-4)],scientific=TRUE,digit=4)
dataF2 <- sort(dataF2);
F2w1<-1/(12*n_samF2)
F2bmw <- matrix(0,n_samF2,1); F2bmwsl <- matrix(0,n_samF2,6)
for(i in 1:6){
F2gg <- (dataF2 - mean3[i])/sqrt(sigma3[i])
F2bmw[which(F2gg>=0)] <- pnorm(F2gg[F2gg>=0])
F2bmw[which(F2gg<0)] <- 1 - pnorm(abs(F2gg[F2gg<0]))
F2bmwsl[,i] <- F2bmw*mix_pi3[i]
}
F2P2 <- rowSums(F2bmwsl)
nn <- dim(as.matrix(unique(F2P2)))[1]
if(nn < n_samF2){F2P2 <- F2P2+runif(n_samF2)/1e4}
F2dd <- as.matrix(c(sum(F2P2),sum(F2P2^2),sum((F2P2-0.5)^2)))
F2WW2 <- 1/(12*n_samF2) + sum((F2P2 - (as.matrix(c(1:n_samF2)) - 0.5)/n_samF2)^2)
F2u <- as.matrix(c(12*n_samF2*((F2dd[1]/n_samF2-0.5)^2),((45*n_samF2)/4)*((F2dd[2]/n_samF2-1/3)^2),180*n_samF2*((F2dd[3]/n_samF2-1/12)^2)))
F2D <- as.numeric(ks.test(F2P2,"punif")[[1]][1])
F2tt <- as.matrix(c((1 - pchisq(F2u[1],1)),(1 - pchisq(F2u[2],1)),(1 - pchisq(F2u[3],1)),K1(F2WW2),(1-pkolm(F2D,n_samF2))))
F2tt[which( F2tt>=10e-4)]<-round(F2tt[which(F2tt>=10e-4)],4);F2tt[which(F2tt<10e-4)]<-format(F2tt[which(F2tt<10e-4)],scientific=TRUE,digit=4)
aa<-matrix(c(1,2,1,0,1,0,0,1,1,-2,-1,0,1,2,0.5,0.25,1,1.5,0.5,0.25,1,1,0.5,0.25,1,1,
-0.5,0.25,1,-0.5,-0.5,0.25,1,-2,-0.5,0.25,1,2,0,0.25,1,1.5,0,0.25,1,0,0,
0.25,1,1,0,0.25,1,-0.5,0,0.25,1,-2,0,0.25),15,4,byrow=T)
b_line1<-as.matrix(c(mean[1],mean[2],mean[3],mean1[1],mean1[2],mean1[3],mean2[1],mean2[2],mean2[3],mean3[1],mean3[2],mean3[3],mean3[4],mean3[5],mean3[6]))
B1<-solve(crossprod(aa,aa))%*%crossprod(aa,b_line1)
jj1<-sigmaB1-sigma1[1]
if (jj1<0 || jj1>=sigmaB1) {jj1<-0}
ll1<-jj1/sigmaB1
mm1<-sigma1[1]-sigma
if (mm1<0 || mm1>=sigmaB1) {mm1<-0}
nn1<-mm1/sigmaB1
jj2<-sigmaB2-sigma2[3]
if (jj2<0 || jj2>=sigmaB2) {jj2<-0}
ll2<-jj2/sigmaB2
mm2<-sigma2[3]-sigma
if (mm2<0 || mm2>=sigmaB2) {mm2<-0}
nn2<-mm2/sigmaB2
jj3<-sigmaF2-sigma3[1]
if (jj3<0 || jj3>=sigmaF2) {jj3<-0}
ll3<-jj3/sigmaF2
mm3<-sigma3[1]-sigma
if (mm3<0 || mm3>=sigmaF2) {mm3<-0}
nn3<-mm3/sigmaF2
output <- data.frame("MX2-EAD-AD",round(abc,4),round(AIC,4),round(meanP1,4),round(meanF1,4),round(meanP2,4), round(sigma0,4),round(t(mean1),4)," ",round(t(sigma1),4)," ",
round(t(mix_pi1),4)," ",round(t(mean2),4)," ",round(t(sigma2),4)," ",round(t(mix_pi2),4)," ",
round(t(mean3),4)," "," "," ",round(t(sigma3),4)," "," "," ",round(t(mix_pi3),4)," "," "," ",
round(B1[1],4)," "," "," "," "," ",round(B1[2],4),round(B1[2],4),round(B1[2],4),round(B1[2],4)," "," "," "," ",round(B1[3],4),round(B1[4],4),
round(jj1,4),round(ll1*100,4),round(mm1,4),round(nn1*100,4),round(jj2,4),round(ll2*100,4),round(mm2,4),round(nn2*100,4),round(jj3,4),round(ll3*100,4),round(mm3,4),round(nn3*100,4),
round(P1u[1],4),P1tt[1],round(P1u[2],4),P1tt[2],round(P1u[3],4),P1tt[3],round(P1w,4),P1tt[4],round(P1D,4),P1tt[5],
round(F1u[1],4),F1tt[1],round(F1u[2],4),F1tt[2],round(F1u[3],4),F1tt[3],round(F1w,4),F1tt[4],round(F1D,4),F1tt[5],
round(P2u[1],4),P2tt[1],round(P2u[2],4),P2tt[2],round(P2u[3],4),P2tt[3],round(P2w,4),P2tt[4],round(P2D,4),P2tt[5],
round(B1u[1],4),B1tt[1],round(B1u[2],4),B1tt[2],round(B1u[3],4),B1tt[3],round(B1WW2,4),B1tt[4],round(B1D,4),B1tt[5],
round(B2u[1],4),B2tt[1],round(B2u[2],4),B2tt[2],round(B2u[3],4),B2tt[3],round(B2WW2,4),B2tt[4],round(B2D,4),B2tt[5],
round(F2u[1],4),F2tt[1],round(F2u[2],4),F2tt[2],round(F2u[3],4),F2tt[3],round(F2WW2,4),F2tt[4],round(F2D,4),F2tt[5])
output<-as.matrix(output)
OUTPUT<-list(output,mi1,mi2,mi3)
return(OUTPUT)
}
K1G6F <- function(x){
V0 <- 0
for(j in 0:2)
{I1 <- 0;I2 <- 0
for(k in 0:8)
{I1 <- I1 + (((4*j+1)^2/(32*x))^(-0.25+2*k))/(gamma(k+1)*gamma(0.75+k))
I2 <- I2 + ((4*j+1)^2/(32*x))^(0.25+2*k)/(gamma(k+1)*gamma(1.25+k))}
V0 <- V0 + (gamma(j+0.5)*sqrt(4*j+1)/(gamma(0.5)*gamma(j+1)))*exp(-(4*j+1)^2/(16*x))*(I1-I2)}
V <- (1/sqrt(2*x))*V0
return (1-V)
}
logLG6F <- function(nm,nng,mi,mn,s,d1) { sum2 <- sum(log(dmixnorm(d1,mn,sqrt(s),mi)));return (sum2) }
if(model=="All models"){
cl.cores <- detectCores()
if(cl.cores<=2){
cl.cores<-1
}else if(cl.cores>2){
if(cl.cores>10){
cl.cores<-10
}else {
cl.cores <- detectCores()-1
}
}
cl <- makeCluster(cl.cores)
registerDoParallel(cl)
i<-NULL
allresult=foreach(i=1:24,.combine = 'rbind')%dopar%{
requireNamespace("KScorrect")
requireNamespace("kolmim")
G6FModelFun[[i]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2)[[1]]
}
stopCluster(cl)
mi1<-NULL;mi2<-NULL;mi3<-NULL
}else{
allresultq=switch(model,"1MG-AD" = G6FModelFun[[1]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"1MG-A"=G6FModelFun[[2]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"1MG-EAD"=G6FModelFun[[3]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"1MG-NCD"=G6FModelFun[[4]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"2MG-ADI"=G6FModelFun[[5]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),
"2MG-AD"=G6FModelFun[[6]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"2MG-A"=G6FModelFun[[7]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"2MG-EA"=G6FModelFun[[8]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"2MG-CD"=G6FModelFun[[9]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"2MG-EAD"=G6FModelFun[[10]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),
"PG-ADI"=G6FModelFun[[11]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"PG-AD"=G6FModelFun[[12]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX1-AD-ADI"=G6FModelFun[[13]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX1-AD-AD"=G6FModelFun[[14]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX1-A-AD"=G6FModelFun[[15]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),
"MX1-EAD-AD"=G6FModelFun[[16]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX1-NCD-AD"=G6FModelFun[[17]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-ADI-ADI"=G6FModelFun[[18]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-ADI-AD"=G6FModelFun[[19]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-AD-AD"=G6FModelFun[[20]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),
"MX2-A-AD"=G6FModelFun[[21]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-EA-AD"=G6FModelFun[[22]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-CD-AD"=G6FModelFun[[23]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2),"MX2-EAD-AD"=G6FModelFun[[24]](K1G6F,logLG6F,df11,df21,df31,df41,df51,df61,G6Ftext2))
allresult<-allresultq[[1]]
if(model=="PG-AD"||model=="PG-ADI"){
mi1<-NULL;mi2<-NULL;mi3<-NULL
}else{
mi1<-allresultq[[2]];mi2<-allresultq[[3]];mi3<-allresultq[[4]]
}
}
colnames(allresult) <- G6Fcolname
out<-list(allresult,mi1,mi2,mi3)
return(out)
}
|
kcde <- function(x, H, h, gridsize, gridtype, xmin, xmax, supp=3.7, eval.points, binned, bgridsize, positive=FALSE, adj.positive, w, verbose=FALSE, tail.flag="lower.tail")
{
ksd <- ks.defaults(x=x, w=w, binned=binned, bgridsize=bgridsize, gridsize=gridsize)
d <- ksd$d; n <- ksd$n; w <- ksd$w
binned <- ksd$binned
gridsize <- ksd$gridsize
bgridsize <- ksd$bgridsize
tail.flag1 <- match.arg(tail.flag, c("lower.tail", "upper.tail"))
if (d==1)
{
if (missing(h) & !positive) h <- hpi.kcde(x=x, binned=default.bflag(d=d, n=n))
Fhat <- kde(x=x, h=h, gridsize=gridsize, gridtype=gridtype, xmin=xmin, xmax=xmax, supp=supp, binned=binned, bgridsize=bgridsize, positive=positive, adj.positive=adj.positive, w=w)
diffe <- abs(diff(Fhat$eval.points))
if (tail.flag1=="lower.tail") Fhat$estimate <- c(0, diffe) * cumsum(Fhat$estimate)
else Fhat$estimate <- c(diffe[1], diffe) * (sum(Fhat$estimate) - cumsum(Fhat$estimate))
}
else if (d==2)
{
if (missing(H) & !positive) H <- Hpi.kcde(x=x, binned=default.bflag(d=d, n=n), bgridsize=bgridsize, verbose=FALSE)
Fhat <- kde(x=x, H=H, gridsize=gridsize, gridtype=gridtype, xmin=xmin, xmax=xmax, supp=supp, binned=binned, bgridsize=bgridsize, w=w, verbose=verbose)
diffe1 <- abs(diff(Fhat$eval.points[[1]]))
diffe2 <- abs(diff(Fhat$eval.points[[2]]))
if (tail.flag1=="lower.tail")
{
Fhat$estimate <- apply(Fhat$estimate, 1, cumsum)*c(0,diffe1)
Fhat$estimate <- apply(t(Fhat$estimate), 2, cumsum)*c(0,diffe2)
}
else
{
Fhatsum <- matrix(apply(Fhat$estimate, 1, sum), ncol=ncol(Fhat$estimate), nrow=nrow(Fhat$estimate), byrow=TRUE)
Fhat$estimate <- (Fhatsum-apply(Fhat$estimate, 1, cumsum))*c(diffe1[1], diffe1)
Fhatsum <- matrix(apply(Fhat$estimate, 1, sum), ncol=ncol(Fhat$estimate), nrow=nrow(Fhat$estimate), byrow=TRUE)
Fhat$estimate <- (Fhatsum-apply(t(Fhat$estimate), 2, cumsum))*c(diffe2[1], diffe2)
}
}
else if (d==3)
{
if (missing(H) & !positive) H <- Hpi.kcde(x=x, binned=default.bflag(d=d, n=n), bgridsize=bgridsize, verbose=FALSE)
Fhat <- kde(x=x, H=H, gridsize=gridsize, gridtype=gridtype, xmin=xmin, xmax=xmax, supp=supp, binned=binned, bgridsize=bgridsize, w=w, verbose=verbose)
Fhat.temp <- Fhat$estimate
diffe1 <- abs(diff(Fhat$eval.points[[1]]))
diffe2 <- abs(diff(Fhat$eval.points[[2]]))
diffe3 <- abs(diff(Fhat$eval.points[[3]]))
if (tail.flag1=="lower.tail")
{
for (i in 1:dim(Fhat$estimate)[3])
{
Fhat.temp[,,i] <- apply(Fhat.temp[,,i], 1, cumsum)*c(0,diffe1)
Fhat.temp[,,i] <- apply(t(Fhat.temp[,,i]), 2, cumsum)*c(0,diffe2)
}
for (i in 1:dim(Fhat$estimate)[1])
for (j in 1:dim(Fhat$estimate)[2])
Fhat.temp[i,j,] <- cumsum(Fhat.temp[i,j,])*c(0,diffe3)
Fhat$estimate <- Fhat.temp
}
else
{
for (i in 1:dim(Fhat$estimate)[3])
{
Fhatsum <- matrix(apply(Fhat.temp[,,i], 1, sum), ncol=ncol(Fhat.temp), nrow=nrow(Fhat.temp), byrow=TRUE)
Fhat.temp[,,i] <- (Fhatsum-apply(Fhat.temp[,,i], 1, cumsum))*c(diffe1[1], diffe1)
Fhatsum <- matrix(apply(Fhat.temp[,,i], 1, sum), ncol=ncol(Fhat.temp), nrow=nrow(Fhat.temp), byrow=TRUE)
Fhat.temp[,,i] <- (Fhatsum-apply(t(Fhat.temp[,,i]), 2, cumsum))*c(diffe2[1],diffe2)
}
for (i in 1:dim(Fhat$estimate)[1])
for (j in 1:dim(Fhat$estimate)[2])
{
Fhatsum <- sum(Fhat.temp[i,j,])
Fhat.temp[i,j,] <- (Fhatsum-cumsum(Fhat.temp[i,j,]))*c(diffe3[1],diffe3)
}
Fhat$estimate <- Fhat.temp
}
}
Fhat$estimate <- Fhat$estimate/max(Fhat$estimate)
if (!missing(eval.points))
{
if (d<=3)
{
Fhat$estimate <- predict(Fhat, x=eval.points)
Fhat$eval.points <- eval.points
}
else
{
Fhat <- kcde.points(x=x, H=H, eval.points=eval.points, w=w, verbose=verbose, tail.flag=tail.flag1)
}
}
Fhat$tail <- tail.flag1
Fhat$type <- "kcde"
class(Fhat) <- "kcde"
return(Fhat)
}
kcde.points <- function(x, H, eval.points, w, verbose=FALSE, tail.flag="lower.tail")
{
n <- nrow(x)
if (verbose) pb <- txtProgressBar()
Fhat <- rep(0, nrow(eval.points))
pmvnorm.temp <- function(x, ...) { return(pmvnorm(mean=x, ...)) }
for (i in 1:nrow(eval.points))
{
if (verbose) setTxtProgressBar(pb, i/(nrow(eval.points)-1))
if (tail.flag=="lower.tail")
Fhat[i] <- sum(apply(x, 1, pmvnorm.temp, upper=eval.points[i,], sigma=H))
else
Fhat[i] <- sum(apply(x, 1, pmvnorm.temp, lower=eval.points[i,], sigma=H))
}
Fhat <- Fhat/n
if (verbose) close(pb)
return(list(x=x, eval.points=eval.points, estimate=Fhat, H=H, gridded=FALSE, binned=FALSE, names=NULL, w=w))
}
plot.kcde <- function(x, ...)
{
Fhat <- x
if (is.vector(Fhat$x)) plotkcde.1d(Fhat, ...)
else
{
d <- ncol(Fhat$x)
if (d==2)
{
opr <- options()$preferRaster; if (!is.null(opr)) if (!opr) options("preferRaster"=TRUE)
plotret <- plotkcde.2d(Fhat, ...)
if (!is.null(opr)) options("preferRaster"=opr)
invisible(plotret)
}
else if (d==3)
{
plotkcde.3d(Fhat, ...)
invisible()
}
else stop ("kde.plot function only available for 1, 2 or 3-d data")
}
}
plotkcde.1d <- function(Fhat, xlab, ylab="Distribution function", add=FALSE, drawpoints=FALSE, col=1, col.pt=4, jitter=FALSE, alpha=1, ...)
{
if (missing(xlab)) xlab <- Fhat$names
if (Fhat$tail=="upper.tail") zlab <- "Survival function"
col <- transparency.col(col, alpha=alpha)
if (add) lines(Fhat$eval.points, Fhat$estimate, xlab=xlab, ylab=ylab, col=col, ...)
else plot(Fhat$eval.points, Fhat$estimate, type="l", xlab=xlab, ylab=ylab, col=col, ...)
if (drawpoints)
if (jitter) rug(jitter(Fhat$x), col=col.pt)
else rug(Fhat$x, col=col.pt)
}
plotkcde.2d <- function(Fhat, display="persp", cont=seq(10,90, by=10), abs.cont,
xlab, ylab, zlab="Distribution function", cex=1, pch=1,
add=FALSE, drawpoints=FALSE, drawlabels=TRUE, theta=-30, phi=40, d=4,
col.pt=4, col, col.fun, alpha=1, lwd=1, border=NA, thin=3, labcex=1, ticktype="detailed", ...)
{
disp1 <- match.arg(display, c("slice", "persp", "image", "filled.contour", "filled.contour2"))
if (disp1=="filled.contour2") disp1 <- "filled.contour"
if (!is.list(Fhat$eval.points)) stop("Needs a grid of density estimates")
if (missing(xlab)) xlab <- Fhat$names[1]
if (missing(ylab)) ylab <- Fhat$names[2]
if (Fhat$tail=="upper.tail") zlab <- "Survival function"
if (missing(col.fun)) col.fun <- function(n) {hcl.colors(n, palette="viridis", alpha=alpha)}
if (disp1=="persp")
{
hts <- seq(0, 1.1*max(Fhat$estimate), length=500)
if (missing(col)) col <- col.fun(n=length(hts)+1)
if (length(col)<(length(hts)+1)) col <- rep(col, length=length(hts)+1)
col <- transparency.col(col, alpha=alpha)
plot.ind <- list(seq(1, length(Fhat$eval.points[[1]]), by=thin), seq(1, length(Fhat$eval.points[[2]]), by=thin))
z <- Fhat$estimate[plot.ind[[1]], plot.ind[[2]]]
nrz <- nrow(z)
ncz <- ncol(z)
zfacet <- z[-1, -1] + z[-1, -ncz] + z[-nrz, -1] + z[-nrz, -ncz]
facetcol <- cut(zfacet, length(hts)+1, labels=FALSE)
plotret <- persp(Fhat$eval.points[[1]][plot.ind[[1]]], Fhat$eval.points[[2]][plot.ind[[2]]], z, theta=theta, phi=phi, d=d, xlab=xlab, ylab=ylab, zlab=zlab, col=col[facetcol], border=border, ticktype=ticktype, ...)
}
else if (disp1=="slice")
{
if (!add) plot(Fhat$x[,1], Fhat$x[,2], type="n", xlab=xlab, ylab=ylab, ...)
if (missing(abs.cont)) hts <- cont/100
else hts <- abs.cont
if (missing(col)) col <- col.fun(n=length(hts))
if (length(col)<length(hts)) col <- rep(col, times=length(hts))
col <- transparency.col(col, alpha=alpha)
for (i in 1:length(hts))
{
if (missing(abs.cont)) scale <- cont[i]/hts[i]
else scale <- 1
if (hts[i]>0)
contour(Fhat$eval.points[[1]], Fhat$eval.points[[2]], Fhat$estimate*scale, level=hts[i]*scale, add=TRUE, drawlabels=drawlabels, col=col[i], lwd=lwd, labcex=labcex, ...)
}
if (drawpoints) points(Fhat$x[,1], Fhat$x[,2], col=col.pt, cex=cex, pch=pch)
}
else if (disp1=="image")
{
if (missing(col)) col <- col.fun(100)
col <- transparency.col(col, alpha=alpha)
image(Fhat$eval.points[[1]], Fhat$eval.points[[2]], Fhat$estimate, xlab=xlab, ylab=ylab, add=add, col=col, ...)
box()
}
else if (disp1=="filled.contour")
{
hts <- cont/100
clev <- c(-0.01*max(abs(Fhat$estimate)), hts, max(c(Fhat$estimate, hts)) + 0.01*max(abs(Fhat$estimate)))
if (missing(col)) col <- col.fun(length(hts))
col <- transparency.col(col, alpha=alpha)
if (!add) plot(Fhat$eval.points[[1]], Fhat$eval.points[[2]], type="n", xlab=xlab, ylab=ylab, ...)
if (tail(hts, n=1) < max(Fhat$estimate)) hts2 <- c(hts, max(Fhat$estimate))
.filled.contour(Fhat$eval.points[[1]], Fhat$eval.points[[2]], Fhat$estimate, levels=hts2, col=col)
if (!missing(lwd))
{
for (i in 1:length(hts))
{
if (missing(abs.cont)) scale <- (100-cont[i])/hts[i]
else scale <- 1
if (lwd >=1) contour(Fhat$eval.points[[1]], Fhat$eval.points[[2]], Fhat$estimate*scale, level=hts[i]*scale, add=TRUE, drawlabels=drawlabels, col=1, lwd=lwd, labcex=labcex, ...)
}
}
}
if (disp1=="persp") invisible(plotret)
else invisible()
}
plotkcde.3d <- function(Fhat, display="plot3D", cont=c(25,50,75), colors, col, alphavec, size=3, cex=1, pch=1, theta=-30, phi=40, d=4, ticktype="detailed", bty="f", col.pt=4, add=FALSE, xlab, ylab, zlab, drawpoints=FALSE, alpha, box=TRUE, axes=TRUE, ...)
{
disp1 <- match.arg(display, c("plot3D", "rgl"))
hts <- sort(cont/100)
nc <- length(hts)
if (missing(col))
{
col.fun <- function(n) {hcl.colors(n, palette="viridis")}
col <- col.fun(n=length(hts))
}
colors <- col
if (missing(xlab)) xlab <- Fhat$names[1]
if (missing(ylab)) ylab <- Fhat$names[2]
if (missing(zlab)) zlab <- Fhat$names[3]
if (missing(alphavec)) alphavec <- seq(0.5,0.1,length=nc)
if (missing(alpha)) alpha <- 0.5
if (!missing(alpha)) {alphavec <- rep(alpha,nc)}
disp1 <- match.arg(display, c("plot3D", "rgl"))
if (disp1 %in% "plot3D")
{
for (i in 1:nc)
if (hts[nc-i+1] < max(Fhat$estimate))
plot3D::isosurf3D(x=Fhat$eval.points[[1]], y=Fhat$eval.points[[2]], z=Fhat$eval.points[[3]], colvar=Fhat$estimate, level=hts[nc-i+1], add=add | (i>1), col=colors[nc-i+1], alpha=alphavec[i], phi=phi, theta=theta, xlab=xlab, ylab=ylab, zlab=zlab, d=d, ticktype=ticktype, bty=bty, ...)
if (drawpoints) plot3D::points3D(x=Fhat$x[,1], y=Fhat$x[,2], z=Fhat$x[,3], cex=cex, col=col.pt, add=TRUE, pch=pch, d=d)
}
else if (disp1 %in% "rgl")
{
if (!requireNamespace("rgl", quietly=TRUE)) stop("Install the rgl package as it is required.", call.=FALSE)
if (!requireNamespace("misc3d", quietly=TRUE)) stop("Install the misc3d package as it is required.", call.=FALSE)
if (drawpoints)
rgl::plot3d(Fhat$x[,1],Fhat$x[,2],Fhat$x[,3], size=size, col=col.pt, alpha=alpha, xlab=xlab, ylab=ylab, zlab=zlab, add=add, box=FALSE, axes=FALSE, ...)
else
rgl::plot3d(Fhat$x[,1],Fhat$x[,2],Fhat$x[,3], type="n", xlab=xlab, ylab=ylab, zlab=zlab, add=add, box=FALSE, axes=FALSE, ...)
rgl::bg3d(col="white")
for (i in 1:nc)
if (hts[nc-i+1] < max(Fhat$estimate))
misc3d::contour3d(Fhat$estimate, level=hts[nc-i+1], x=Fhat$eval.points[[1]], y=Fhat$eval.points[[2]], z=Fhat$eval.points[[3]], add=TRUE, color=colors[nc-i+1], alpha=alphavec[i], box=FALSE, axes=FALSE, ...)
if (box) rgl::box3d()
if (axes) rgl::axes3d(c("x","y","z"))
}
}
hns.kcde <- function(x)
{
d <- 1
n <- length(x)
sigma <- sd(x)
hns <- 4^(1/3)*sigma*n^(-1/3)
return(hns)
}
Hns.kcde <- function(x)
{
if (is.vector(x)) {return(hns.kcde(x)^2)}
d <- ncol(x)
n <- nrow(x)
m1 <- (4*pi)^(-1/2)
Jd <- matrix(1, ncol=d, nrow=d)
Sigma <- var(x)
Hns <- (4*det(Sigma)^(1/2)*tr(matrix.sqrt(Sigma))/tr(Sigma))^(2/3)*Sigma*n^(-2/3)
return(Hns)
}
hpi.kcde <- function(x, nstage=2, binned, amise=FALSE)
{
n <- length(x)
d <- 1
if (missing(binned)) binned <- default.bflag(d,n)
K2 <- dnorm.deriv(x=0, mu=0, sigma=1, deriv.order=2)
K4 <- dnorm.deriv(x=0, mu=0, sigma=1, deriv.order=4)
m2 <- 1
m1 <- (4*pi)^(-1/2)
if (nstage==2)
{
psi6.hat <- psins.1d(r=6, sigma=sd(x))
gamse4 <- (2*K4/(-m2*psi6.hat*n))^(1/(4+3))
psi4.hat <- kfe.1d(x=x, g=gamse4, deriv.order=4, inc=1, binned=binned)
gamse2 <- (2*K2/(-m2*psi4.hat*n))^(1/(2+3))
psi2.hat <- kfe.1d(x=x, g=gamse2, deriv.order=2, inc=1, binned=binned)
}
else
{
psi4.hat <- psins.1d(r=4, sigma=sd(x))
gamse2 <- (2*K2/(-m2*psi4.hat*n))^(1/(2+3))
psi2.hat <- kfe.1d(x=x, g=gamse2, deriv.order=2, inc=1, binned=binned)
}
h <- (2*m1/(-m2^2*psi2.hat*n))^(1/3)
if (amise) PI <- -2*n^(-1)*m1*h - 1/4*psi2.hat*h^4
if (!amise) return(h)
else return(list(h=h, PI=PI))
}
Hpi.kcde <- function(x, nstage=2, pilot, Hstart, binned, bgridsize, amise=FALSE, verbose=FALSE, optim.fun="optim", pre=TRUE)
{
n <- nrow(x)
d <- ncol(x)
m1 <- (4*pi)^(-1/2)
Jd <- matrix(1, ncol=d, nrow=d)
if (missing(binned)) binned <- default.bflag(d,n)
if(!is.matrix(x)) x <- as.matrix(x)
if (missing(pilot)) pilot <- "dunconstr"
pilot1 <- match.arg(pilot, c("dunconstr", "dscalar"))
if (pre) { S12 <- diag(sqrt(diag(var(x)))); x <- pre.scale(x) }
D2K0 <- t(dmvnorm.deriv(x=rep(0,d), mu=rep(0,d), Sigma=diag(d), deriv.order=2))
if (nstage==2)
{
psi4.ns <- psins(r=4, Sigma=var(x), deriv.vec=TRUE)
amse2.temp <- function(vechH)
{
H <- invvech(vechH) %*% invvech(vechH)
Hinv <- chol2inv(chol(H))
Hinv12 <- matrix.sqrt(Hinv)
amse2.val <- 1/(det(H)^(1/2)*n)*((Hinv12 %x% Hinv12) %*% D2K0) + 1/2* t(vec(H) %x% diag(d^2)) %*% psi4.ns
return(sum(amse2.val^2))
}
Hstart2 <- matrix.sqrt(Gns(r=2, n=n, Sigma=var(x)))
optim.fun1 <- match.arg(optim.fun, c("nlm", "optim"))
if (optim.fun1=="nlm")
{
result <- nlm(p=vech(Hstart2), f=amse2.temp, print.level=2*as.numeric(verbose))
H2 <- invvech(result$estimate) %*% invvech(result$estimate)
}
else
{
result <- optim(vech(Hstart2), amse2.temp, method="BFGS", control=list(trace=as.numeric(verbose), REPORT=1))
H2 <- invvech(result$par) %*% invvech(result$par)
}
psi2.hat <- kfe(x=x, G=H2, deriv.order=2, add.index=FALSE, binned=binned, bgridsize=bgridsize, verbose=verbose)
}
else
{
psi2.hat <- psins(r=2, Sigma=var(x), deriv.vec=TRUE)
H2 <- Gns(r=2, n=n, Sigma=var(x))
}
if (missing(Hstart)) Hstart <- Hns.kcde(x=x)
amise.temp <- function(vechH)
{
H <- invvech(vechH) %*% invvech(vechH)
H12 <- matrix.sqrt(H)
amise.val <- -2*n^(-1)*m1*tr(H12) - 1/4*t(vec(H %*% H)) %*% psi2.hat
return(drop(amise.val))
}
Hstart <- matrix.sqrt(Hstart)
optim.fun1 <- match.arg(optim.fun, c("optim", "nlm"))
if (optim.fun1=="nlm")
{
result <- nlm(p=vech(Hstart), f=amise.temp, print.level=2*as.numeric(verbose))
H <- invvech(result$estimate) %*% invvech(result$estimate)
amise.star <- result$minimum
}
else
{
result <- optim(vech(Hstart), amise.temp, method="BFGS", control=list(trace=as.numeric(verbose), REPORT=1))
H <- invvech(result$par) %*% invvech(result$par)
amise.star <- result$value
}
if (pre) H <- S12 %*% H %*% S12
if (!amise) return(H)
else return(list(H=H, PI=amise.star))
}
Hpi.diag.kcde <- function(x, nstage=2, pilot, Hstart, binned=FALSE, bgridsize, amise=FALSE, verbose=FALSE, optim.fun="optim", pre=TRUE)
{
n <- nrow(x)
d <- ncol(x)
m1 <- (4*pi)^(-1/2)
Jd <- matrix(1, ncol=d, nrow=d)
if (missing(binned)) binned <- default.bflag(d,n)
if(!is.matrix(x)) x <- as.matrix(x)
if (missing(pilot)) pilot <- "dscalar"
pilot1 <- match.arg(pilot, c("dunconstr", "dscalar"))
if (pre) { S12 <- diag(sqrt(diag(var(x)))); x <- pre.scale(x) }
D2K0 <- t(dmvnorm.deriv(x=rep(0,d), mu=rep(0,d), Sigma=diag(d), deriv.order=2))
if (nstage==2)
{
psi4.ns <- psins(r=4, Sigma=var(x), deriv.vec=TRUE)
amse2.temp <- function(diagH)
{
H <- diag(diagH) %*% diag(diagH)
Hinv <- chol2inv(chol(H))
Hinv12 <- matrix.sqrt(Hinv)
amse2.val <- 1/(det(H)^(1/2)*n)*((Hinv12 %x% Hinv12) %*% D2K0) + 1/2* t(vec(H) %x% diag(d^2)) %*% psi4.ns
return(sum(amse2.val^2))
}
Hstart2 <- matrix.sqrt(Gns(r=2, n=n, Sigma=var(x)))
optim.fun1 <- match.arg(optim.fun, c("optim", "nlm"))
if (optim.fun1=="nlm")
{
result <- nlm(p=diag(Hstart2), f=amse2.temp, print.level=2*as.numeric(verbose))
H2 <- diag(result$estimate) %*% diag(result$estimate)
}
else
{
result <- optim(diag(Hstart2), amse2.temp, method="BFGS", control=list(trace=as.numeric(verbose), REPORT=1))
H2 <- diag(result$par) %*% diag(result$par)
}
psi2.hat <- kfe(x=x, G=H2, deriv.order=2, add.index=FALSE, binned=binned, bgridsize=bgridsize, verbose=verbose)
}
else
psi2.hat <- psins(r=2, Sigma=var(x), deriv.vec=TRUE)
if (missing(Hstart)) Hstart <- Hns.kcde(x=x)
amise.temp <- function(diagH)
{
H <- diag(diagH) %*% diag(diagH)
H12 <- matrix.sqrt(H)
amise.val <- -2*n^(-1)*m1*tr(H12) - 1/4*t(vec(H %*% H)) %*% psi2.hat
return(drop(amise.val))
}
Hstart <- matrix.sqrt(Hstart)
optim.fun1 <- match.arg(optim.fun, c("optim", "nlm"))
if (optim.fun1=="nlm")
{
result <- nlm(p=diag(Hstart), f=amise.temp, print.level=2*as.numeric(verbose))
H <- diag(result$estimate) %*% diag(result$estimate)
amise.star <- result$minimum
}
else
{
result <- optim(diag(Hstart), amise.temp, method="BFGS", control=list(trace=as.numeric(verbose), REPORT=1))
H <- diag(result$par) %*% diag(result$par)
amise.star <- result$value
}
if (pre) H <- S12 %*% H %*% S12
if (!amise) return(H)
else return(list(H=H, PI=amise.star))
}
kroc <- function(x1, x2, H1, h1, hy, gridsize, gridtype, xmin, xmax, supp=3.7, eval.points, binned, bgridsize, positive=FALSE, adj.positive, w, verbose=FALSE)
{
if (is.vector(x1)) {d <- 1; n1 <- length(x1)} else {d <- ncol(x1); n1 <- nrow(x1); x1 <- as.matrix(x1); x2 <- as.matrix(x2)}
if (!missing(eval.points)) stop("eval.points in kroc not yet implemented")
if (d==1)
{
if (missing(h1)) h1 <- hpi.kcde(x=x1, binned=default.bflag(d=d, n=n1))
Fhatx1 <- kcde(x=x1, h=h1, gridsize=gridsize, gridtype=gridtype, xmin=xmin, xmax=xmax, supp=supp, binned=binned, bgridsize=bgridsize, positive=positive, adj.positive=adj.positive, w=w, tail.flag="upper.tail")
}
else
{
if (missing(H1)) H1 <- Hpi.kcde(x=x1, binned=default.bflag(d=d, n=n1), verbose=verbose)
Fhatx1 <- kcde(x=x1, H=H1, gridsize=gridsize, gridtype=gridtype, xmin=xmin, xmax=xmax, supp=supp, binned=binned, bgridsize=bgridsize, w=w, tail.flag="upper.tail", verbose=verbose)
}
y1 <- predict(Fhatx1, x=x1)
y2 <- predict(Fhatx1, x=x2)
y1 <- qnorm(y1[y1>0])
y2 <- qnorm(y2[y2>0])
if (missing(hy)) hy <- hpi.kcde(y2, binned=default.bflag(d=1, n=n1))
Fhaty2 <- kcde(x=y2, h=hy, binned=TRUE, xmin=min(y1,y2)-3.7*hy, xmax=max(y1,y2)+3.7*hy)
Fhaty1 <- kcde(x=y1, h=hy, binned=TRUE, xmin=min(y1,y2)-3.7*hy, xmax=max(y1,y2)+3.7*hy)
Fhaty1$eval.points <- pnorm(Fhaty1$eval.points)
Fhaty2$eval.points <- pnorm(Fhaty2$eval.points)
Rhat <- Fhaty1
Rhat$eval.points <- Fhaty1$estimate
Rhat$estimate <- Fhaty2$estimate
if (d==1) {Rhat$h1 <- h1; Rhat$H1 <- h1^2; Rhat$hy <- hy}
else {Rhat$H1 <- H1; Rhat$hy <- hy}
Rhat.smoothed <- smooth.spline(Rhat$eval.points, Rhat$estimate, spar=0.5)
Rhat.smoothed <- predict(Rhat.smoothed, x=seq(0,1,length=length(Rhat$eval.points)))
Rhat$eval.points <- Rhat.smoothed$x
Rhat$estimate <- Rhat.smoothed$y
if (head(Rhat$eval.points, n=1)!=0) Rhat$eval.points[1] <- 0
if (head(Rhat$estimate, n=1)!=0) Rhat$estimate[1] <- 0
if (tail(Rhat$eval.points, n=1)!=1) Rhat$eval.points[length(Rhat$eval.points)] <- 1
if (tail(Rhat$estimate, n=1)!=1) Rhat$estimate[length(Rhat$estimate)] <- 1
Rhat$estimate[Rhat$estimate>1] <- 1
Rhat$estimate[Rhat$estimate<0] <- 0
Rhat$indices <- indices.kroc(Rhat)
Rhat <- Rhat[-c(4,5)]
Rhat$type <- "kroc"
class(Rhat) <- "kroc"
return(Rhat)
}
indices.kroc <- function(Rhat)
{
auc <- sum(abs((head(Rhat$estimate, n=-1) - tail(Rhat$estimate, n=-1)))*abs(diff(Rhat$eval.points))/2 + head(Rhat$estimate, n=-1)*abs(diff(Rhat$eval.points)))
youden.val <- Rhat$estimate - Rhat$eval.points
if (max(youden.val)>0.001)
{
youden.ind <- which.max(youden.val)
youden <- youden.val[youden.ind]
LR <- list(minus=(1-Rhat$estimate[youden.ind])/(1-Rhat$eval.points[youden.ind]), plus=Rhat$estimate[youden.ind]/Rhat$eval.points[youden.ind])
}
else
LR <- list(minus=1, plus=1)
return(list(auc=auc, youden=max(youden.val), LR=LR))
}
plot.kroc <- function(x, add=FALSE, add.roc.ref=FALSE, xlab, ylab, alpha=1, col=1, ...)
{
Rhat <- x
col <- transparency.col(col, alpha=alpha)
if (missing(ylab)) ylab <- "True positive rate (sensitivity)"
if (missing(xlab)) xlab <- expression("False positive rate"~~group("(", list(bar(specificity)), ")"))
if (add) lines(Rhat$eval.points, Rhat$estimate, ...)
else plot(Rhat$eval.points, Rhat$estimate, type="l", ylab=ylab, xlab=xlab, col=col, ...)
if (is.vector(Rhat$x[[1]])) d <- 1 else d <- ncol(Rhat$x[[1]])
if (add.roc.ref)
{
z <- seq(0,1, length=401)
kind <- 0:(d-1)
roc.indep <- 0
for (k in kind) roc.indep <- roc.indep + z*(-log(z))^k/factorial(k)
lines(z, roc.indep, lty=2, col="grey")
}
}
summary.kroc <- function(object, ...)
{
cat("Summary measures for ROC curve\nAUC =", signif(object$indices$auc, ...), "\n")
cat("Youden index =", signif(object$indices$youden, ...), "\n")
cat(paste("(LR-, LR+) = (", signif(object$indices$LR$minus, ...), ", ", signif(object$indices$LR$plus, ...),")\n\n",sep=""))
}
predict.kcde <- function(object, ..., x)
{
return(predict.kde(object=object, ..., x=x, zero.flag=FALSE))
}
predict.kroc <- function(object, ..., x)
{
return(predict.kde(object=object, ..., x=x, zero.flag=FALSE))
}
contourLevels.kcde <- function(x, prob, cont, nlevels=5, ...)
{
fhat <- x
if (missing(prob) & missing(cont)) hts <- pretty(fhat$estimate, n=nlevels)
if (!missing(prob) & missing(cont)) { hts <- prob/100; names(hts) <- paste0(prob, "%") }
if (missing(prob) & !missing(cont)) { prob <- 100-cont; hts <- prob/100; names(hts) <- paste0(prob, "%") }
return(hts)
}
|
context("Checking r_data_frame")
test_that("r_data_frame ...",{
})
|
context("Missing data imputation - data imputation")
library(missCompare)
data("clindata_miss")
small <- clindata_miss[1:60, 1:4]
small$string <- "string"
test_that("string errors in impute_data", {
expect_error(impute_data(small))
})
small <- clindata_miss[1:60, 1:4]
test_that("factors error when methods dont support it", {
expect_error(impute_data(small, scale = T, sel_method = c(2:10,13)))
})
small <- clindata_miss[1:40, 1:4]
test_that("factors OK scaling runs OK", {
expect_error(impute_data(small, n.iter = 1, scale = T, sel_method = c(1,11,12,14:16)), NA)
})
small <- clindata_miss[1:40, 1:4]
test_that("factors OK no scaling runs OK", {
expect_error(impute_data(small, n.iter = 1, scale = F, sel_method = c(1,11,12,14:16)), NA)
})
small <- clindata_miss[1:40, 3:7]
test_that("runs OK when all numeric and with scaling", {
expect_error(impute_data(small, n.iter = 1, scale = T, sel_method = c(1:16)), NA)
})
small <- clindata_miss[1:40, 3:7]
test_that("runs OK when all numeric and without scaling", {
expect_error(suppressWarnings(impute_data(small, n.iter = 1, scale = F, sel_method = c(1:16))), NA)
})
small <- clindata_miss[1:40, 3:7]
imputed <- impute_data(small, scale = T, n.iter = 2, sel_method = c(2:5, 7:9, 16))
test_that("median imputation error", {
expect_error(imputed$median_imputation[[2]])
})
test_that("mean imputation error", {
expect_error(imputed$mean_imputation[[2]])
})
test_that("missMDA EM imputation error", {
expect_error(imputed$missMDA_EM_imputation[[2]])
})
test_that("missMDA reg imputation error", {
expect_error(imputed$missMDA_reg_imputation[[2]])
})
test_that("pcaMethods svd imputation error", {
expect_error(imputed$pcaMethods_svdImpute_imputation[[2]])
})
test_that("pcaMethods BPCA imputation error", {
expect_error(imputed$pcaMethods_BPCA_imputation[[2]])
})
test_that("pcaMethods Nipals imputation error", {
expect_error(imputed$pcaMethods_Nipals_imputation[[2]])
})
test_that("VIM kNN imputation error", {
expect_error(imputed$VIM_kNN_imputation[[2]])
})
df_imp <- imputed$VIM_kNN_imputation[[1]]
test_that("scaling on, post imp diag no error", {
expect_error(suppressWarnings(post_imp_diag(small, df_imp, scale = T, n.boot = 2)), NA)
})
test_that("post imp diag dim error", {
expect_error(post_imp_diag(small[,1:4], df_imp, scale = T, n.boot = 2))
})
imp_res <- suppressWarnings(post_imp_diag(small, df_imp, scale = T, n.boot = 2))
test_that("barcharts not present", {
expect_true(length(imp_res$Barcharts)==0)
})
small <- clindata_miss[1:100, 1:4]
imputed <- impute_data(small, scale = F, n.iter = 1, sel_method = c(1))
df_imp <- imputed$random_replacement[[1]]
imp_res <- suppressWarnings(post_imp_diag(small, df_imp, scale = F, n.boot = 3))
test_that("barchart is present", {
expect_false(length(imp_res$Barcharts)==0)
})
rm(list=ls())
|
gxeMegaEnv <- function(TD,
trials = names(TD),
trait,
method = c("max", "min"),
byYear = FALSE) {
if (missing(TD) || !inherits(TD, "TD")) {
stop("TD should be a valid object of class TD.\n")
}
trials <- chkTrials(trials, TD)
TDTot <- Reduce(f = rbind, x = TD[trials])
chkCol(trait, TDTot)
chkCol("trial", TDTot)
chkCol("genotype", TDTot)
if (byYear) {
chkCol("year", TDTot)
}
method <- match.arg(method)
if (hasName(x = TDTot, name = "megaEnv")) {
warning("TD already contains a column megaEnv. This column will",
"be overwritten.\n", call. = FALSE)
}
allNA <- by(TDTot, TDTot[["genotype"]], FUN = function(x) {
all(is.na(x[trait]))
})
TDTot <- TDTot[!TDTot[["genotype"]] %in% names(allNA[allNA]), ]
rmYear <- FALSE
if (!byYear) {
TDTot[["year"]] <- 0
rmYear <- TRUE
}
envLevels <- levels(TDTot[["trial"]])[levels(TDTot[["trial"]]) %in% trials]
TDTot[["trial"]] <- droplevels(TDTot[["trial"]])
AMMI <- gxeAmmi(TD = createTD(TDTot), trait = trait, nPC = 2, byYear = byYear)
winGeno <- by(data = AMMI$fitted, INDICES = AMMI$fitted[["trial"]],
FUN = function(trial) {
selGeno <- do.call(paste0("which.", method),
args = list(trial[["fittedValue"]]))
as.character(trial[["genotype"]])[selGeno]
})
winGenoVal <- by(data = AMMI$fitted, INDICES = AMMI$fitted[["trial"]],
FUN = function(trial) {
do.call(method, args = list(trial[["fittedValue"]]))
})
megaFactor <- factor(winGeno,
labels = paste0("megaEnv_", seq_along(unique(winGeno))))
TDTot[["megaEnv"]] <- TDTot[["trial"]]
levels(TDTot[["megaEnv"]]) <- as.character(megaFactor)
levels(TDTot[["trial"]]) <- envLevels
if (isTRUE(rmYear)) {
TDTot <- TDTot[-which(colnames(TDTot) == "year")]
}
TDTot[["megaEnv"]] <- factor(as.character(TDTot[["megaEnv"]]))
TDOut <- createTD(TDTot)
summTab <- data.frame("Mega_factor" = megaFactor,
Trial = names(winGeno),
"Winning_genotype" = as.character(winGeno),
"AMMI_estimates" = as.numeric(winGenoVal))
summTab <- summTab[order(megaFactor), ]
return(createMegaEnv(TD = TDOut, summTab = summTab, trait = trait))
}
|
if(getRversion() >= "2.15.1")
utils::globalVariables(c("gpr","dS","alpha","epsilon",
"stabilize","type","lambda","x"))
|
expected <- eval(parse(text="structure(list(raster = structure(\"
test(id=0, code={
argv <- eval(parse(text="list(structure(list(raster = structure(\"
do.call(`invisible`, argv);
}, o=expected);
|
sim.pdata <- function(N=1000, sigma=1, B=3, keep.all=FALSE, show.plot=TRUE) {
if(FALSE) x <- NULL
N <- round(N[1])
stopifNegative(sigma, allowZero=FALSE)
stopifNegative(B, allowZero=FALSE)
u1 <-runif(N, 0, 2*B)
u2 <- runif(N, 0, 2*B)
d <- sqrt((u1 - B)^2 + (u2 - B)^2)
N.real <- sum(d<= B)
p <- ifelse(d < B, 1, 0) * exp(-d*d/(2*(sigma^2)))
y <- rbinom(N, 1, p)
if(show.plot) {
op <- par(mfrow = c(1,2)) ; on.exit(par(op))
tryPlot <- try( {
curve(exp(-x^2/(2*sigma^2)), 0, B, xlab="Distance (x)", ylab="Detection prob.",
lwd = 2, main = "Detection function", ylim = c(0,1))
text(0.8*B, 0.9, paste("sigma:", sigma))
plot(u1, u2, asp = 1, pch = 1, main = "Point transect")
points(u1[d <= B], u2[d <= B], pch = 16, col = "black")
points(u1[y==1], u2[y==1], pch = 16, col = "blue")
points(B, B, pch = "+", cex = 3, col = "red")
plotrix::draw.circle(B, B, B)
}, silent = TRUE)
if(inherits(tryPlot, "try-error"))
tryPlotError(tryPlot)
}
if(!keep.all){
u1 <- u1[y==1]
u2 <- u2[y==1]
d <- d[y==1]
}
return(list(N=N, sigma=sigma, B=B, u1=u1, u2=u2, d=d, y=y, N.real=N.real))
}
|
rcmvtruncnorm <- function(
n,
mean, sigma, lower, upper,
dependent.ind, given.ind, X.given,
init = rep(0, length(mean)),
burn = 10L, thin = 1
) {
check_constants(n)
if (n == 0) {stop("Error: The number of random samples must be positive integer.")}
check_constants(burn)
check_constants(thin)
params <- condtMVN(
mean = mean, sigma = sigma,
lower = lower, upper = upper,
dependent.ind = dependent.ind,
given.ind = given.ind, X.given = X.given,
init = init
)
if (length(dependent.ind) == 1) {
val <- truncnorm::rtruncnorm(
n = n,
mean = params$condMean,
sd = params$condVar,
a = params$condLower,
b = params$condUpper
)
} else {
val <- tmvmixnorm::rtmvn(
n = n,
Mean = params$condMean,
Sigma = params$condVar,
lower = params$condLower,
upper = params$condUpper,
int = params$condInit,
burn = burn,
thin = thin
)
}
return(val)
}
check_constants <- function(K) {
if (is.null(K))
stop(sprintf(" must be non-null."), call. = TRUE)
if (!is.numeric(K) | length(K) != 1)
stop(sprintf(" must be numeric of length 1"), call. = TRUE)
if (!is.wholenumber(K)) {
stop(sprintf(" must be a non-negative integer"), call. = TRUE)
}
return(K)
}
is.integer <- function(x, tol = .Machine$double.eps^0.5) {
abs(x - round(x)) < tol
}
is.wholenumber <- function(x, tol = .Machine$double.eps^0.5) {
x > -1 && is.integer(x, tol)
}
is.naturalnumber <- function(x, tol = .Machine$double.eps^0.5) {
x > 0 && is.integer(x, tol)
}
|
require(distrMod)
options("newDevice"=TRUE)
x <- rnorm(30)
NF <- NormLocationScaleFamily()
system.time(print(MDEstimator(x,NF,CvMDist)))
system.time(print(MDEstimator(x,NF,CvMDist,useApply=TRUE)))
MDEstimator(rnorm(30),NF,CvMDist)
MDEstimator(rnorm(30),NF,CvMDist)
MDEstimator(rnorm(300),NF,CvMDist)
MDEstimator(rnorm(300,mean=2,sd=2),NF,CvMDist)
MDEstimator(rnorm(300,mean=2,sd=2),NF,CvMDist)
|
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
)
knitr::include_graphics("type-hierarchy.png", dpi = 300)
as.integer(1.5)
as.integer(1e10)
library(bignum)
as_biginteger(1.5)
as.double(biginteger(10)^16L)
as.double(bigfloat(1) / 3)
as_biginteger(bigfloat(1.5))
as_bigfloat(biginteger(10)^51L + 1L)
|
data("Titanic", package = "datasets")
ttnc <- as.data.frame(Titanic)
ttnc <- ttnc[rep(1:nrow(ttnc), ttnc$Freq), 1:4]
names(ttnc)[2] <- "Gender"
data("CPS1985", package = "AER")
library("partykit")
ct_ttnc <- ctree(Survived ~ Gender + Age + Class, data = ttnc, alpha = 0.01)
plot(ct_ttnc)
ct_cps <- ctree(log(wage) ~ education + experience + age + ethnicity + gender + union, data = CPS1985, alpha = 0.01)
plot(ct_cps)
mob_cps <- lmtree(log(wage) ~ education | experience + age + ethnicity + gender + union, data = CPS1985)
plot(mob_cps)
plot(Survived ~ Gender, data = ttnc)
tab <- xtabs(~ Survived + Gender, data = ttnc)
chisq.test(tab)
plot(Survived ~ Age, data = ttnc)
tab <- xtabs(~ Survived + Age, data = ttnc)
chisq.test(tab)
plot(Survived ~ Class, data = ttnc)
tab <- xtabs(~ Survived + Class, data = ttnc)
chisq.test(tab)
plot(log(wage) ~ education, data = CPS1985)
cor.test(~ log(wage) + education, data = CPS1985)
plot(log(wage) ~ gender, data = CPS1985)
t.test(log(wage) ~ gender, data = CPS1985)
library("partykit")
ct_ttnc <- ctree(Survived ~ Gender + Age + Class, data = ttnc)
plot(ct_ttnc)
print(ct_ttnc)
ndm <- data.frame(Gender = "Male", Age = "Adult", Class = c("1st", "2nd", "3rd"))
predict(ct_ttnc, newdata = ndm, type = "node")
predict(ct_ttnc, newdata = ndm, type = "response")
predict(ct_ttnc, newdata = ndm, type = "prob")
ndf <- data.frame(Gender = "Female", Age = "Adult", Class = c("1st", "2nd", "3rd"))
ndc <- data.frame(Gender = "Male", Age = "Child", Class = c("1st", "2nd", "3rd"))
cbind(
Male = predict(ct_ttnc, newdata = ndm, type = "prob")[, 2],
Female = predict(ct_ttnc, newdata = ndf, type = "prob")[, 2],
Child = predict(ct_ttnc, newdata = ndc, type = "prob")[, 2]
)
ct_ttnc2 <- ctree(Survived ~ Gender + Age + Class, data = ttnc,
alpha = 0.01, minbucket = 5, minsplit = 15, maxdepth = 4)
plot(ct_ttnc2)
predict(ct_ttnc2, newdata = ndc, type = "prob")
ttnc$Fit <- predict(ct_ttnc2, type = "response")
ttnc$Group <- factor(predict(ct_ttnc2, type = "node"))
xtabs(~ Fit + Survived, data = ttnc)
tab <- xtabs(~ Group + Survived, data = ttnc)
prop.table(tab, 1)
library("ROCR")
pred <- prediction(predict(ct_ttnc, type = "prob")[, 2], ttnc$Survived)
plot(performance(pred, "acc"))
plot(performance(pred, "tpr", "fpr"))
abline(0, 1, lty = 2)
library("rpart")
rp_ttnc <- rpart(Survived ~ Gender + Age + Class, data = ttnc)
plot(rp_ttnc)
text(rp_ttnc)
print(rp_ttnc)
py_ttnc <- as.party(rp_ttnc)
plot(py_ttnc)
print(py_ttnc)
rp_ttnc$cptable
prune(rp_ttnc, cp = 0.1)
ttnc <- transform(ttnc,
Treatment = factor(Gender == "Female" | Age == "Child",
levels = c(FALSE, TRUE), labels = c("Male&Adult", "Female|Child")
)
)
mob_ttnc <- glmtree(Survived ~ Treatment | Class + Gender + Age,
data = ttnc, family = binomial, alpha = 0.01)
plot(mob_ttnc)
print(mob_ttnc)
library("evtree")
set.seed(1)
ev_ttnc <- evtree(Survived ~ Gender + Age + Class, data = ttnc)
plot(ev_ttnc)
ev_ttnc
library("ggparty")
theme_set(theme_minimal())
autoplot(ct_ttnc2)
autoplot(ct_cps)
autoplot(py_ttnc)
autoplot(ev_ttnc)
|
predict.fbRanks=function(object, ..., newdata=list(home.team="foo", away.team="bar"),
max.date="2100-6-1", min.date="1900-5-1", rnd=TRUE, silent=FALSE, show.matches=TRUE, verbose=FALSE,
remove.outliers=TRUE, n=100000){
x=object
the.fits=x$fit
clusters=x$graph
team.data=x$teams
cc = tolower(names(team.data))=="name"
all.team.names=team.data[,cc]
nteams = length(all.team.names)
if(missing(max.date)) max.date=as.Date(max.date)
else max.date=as.Date(max.date, x$date.format)
if(is.na(max.date)) stop(paste("max.date must be entered in the following format:",format(Sys.Date(),x$date.format),"\n"))
if(missing(min.date)) min.date=as.Date(min.date)
else min.date=as.Date(min.date, x$date.format)
if(is.na(min.date)) stop(paste("min.date must be entered in the following format:",format(Sys.Date(),x$date.format),"\n"))
if(!missing(newdata)){
scores=create.newdata.dataframe(x, newdata, min.date, max.date, ...)
}else{
scores = x$scores
include.scores=team.and.score.filters(list(scores=scores, teams=x$teams),...)$include.scores
scores=scores[include.scores,,drop=FALSE]
scores = scores[scores$date>=min.date,,drop=FALSE]
scores = scores[scores$date<=max.date,,drop=FALSE]
}
if(dim(scores)[1]==0) stop("No matches to predict. Either you didn't specify home and away teams or the scores database \n in your fbRanks object has no matches for your specified dates and filter values.")
el=cbind(as.character(scores$home.team),as.character(scores$away.team))
tmp.fun = function(x,y){ any(x %in% y) }
if(!silent){
cat("Predicted Match Results for ")
cat(format(min.date,x$date.format)); cat(" to "); cat(format(max.date,x$date.format)); cat("\n")
cat("Model based on data from ")
cat(format(x$min.date,x$date.format)); cat(" to "); cat(format(x$max.date,x$date.format)); cat("\n---------------------------------------------\n")
}
coef.list = coef(object)$coef.list
for(clus in 1:length(the.fits)){
fit=the.fits[[clus]]
names.in.clus = clusters$names[clusters$membership == clus]
rows.clus = apply(el,1,tmp.fun,names.in.clus)
if(!any(rows.clus)) next
scores.clus = scores[rows.clus,,drop=FALSE]
pred.name=attr(fit$terms, "term.labels")[!(attr(fit$terms, "term.labels") %in% c("attack","defend"))]
s.pred.name=home.away.predictors=both.predictors=character(0)
if(length(pred.name)!=0){
s.pred.name=pred.name
s.pred.name[str_sub(pred.name,-2)==".f"]=str_sub(pred.name[str_sub(pred.name,-2)==".f"],end=-3)
scores.predictor.names=names(scores.clus)[!(names(scores.clus) %in% c("date","home.team","home.score","away.team","away.score"))]
home.away.predictors = scores.predictor.names[str_sub(scores.predictor.names,1,5)=="home." | str_sub(scores.predictor.names,1,5)=="away."]
both.predictors = scores.predictor.names[!(scores.predictor.names %in% home.away.predictors)]
home.away.predictors = unique(str_sub(home.away.predictors,6))
bad.pred.name = s.pred.name[!(s.pred.name %in% both.predictors | s.pred.name %in% home.away.predictors)]
if(length(bad.pred.name)!=0){
stop(paste("The predictor",paste(bad.pred.name,collapse=", "),"is missing from newdata argument.\n It needs to be specified because it is used in the model.\n"))
}
for(ha.pred in s.pred.name[s.pred.name %in% home.away.predictors]){
tmp.name = paste("home.",ha.pred,sep="")
if(!(tmp.name %in% names(scores.clus)))
stop(paste(tmp.name,"if missing from the newdata argument and it is required since it is in the model"),call.=FALSE)
tmp.name = paste("away.",ha.pred,sep="")
if(!(tmp.name %in% names(scores.clus)))
stop(paste(tmp.name,"if missing from the newdata argument and it is required since it is in the model"),call.=FALSE)
}
}
newdata1= data.frame(attack=factor(scores.clus$home.team,levels=fit$xlevels$attack),
defend=factor(scores.clus$away.team,levels=fit$xlevels$defend))
for(ii in s.pred.name){
i = which(ii == s.pred.name)
if(s.pred.name[i] %in% home.away.predictors) s.name = paste("home.",s.pred.name[i],sep="")
else s.name = s.pred.name[i]
if(pred.name[i] %in% names(fit$xlevels)){
newdata1=cbind(newdata1,factor(scores.clus[[s.name]],levels=fit$xlevels[[pred.name[i]]]))
}else{ newdata1=cbind(newdata1,scores.clus[[s.name]]) }
colnames(newdata1)[dim(newdata1)[2]]=pred.name[i]
}
newdata2= data.frame(defend=factor(scores.clus$home.team,levels=fit$xlevels$defend),
attack=factor(scores.clus$away.team,levels=fit$xlevels$attack))
for(ii in s.pred.name){
i = which(ii == s.pred.name)
if(s.pred.name[i] %in% home.away.predictors) s.name = paste("away.",s.pred.name[i],sep="")
else s.name = s.pred.name[i]
if(pred.name[i] %in% names(fit$xlevels)){
newdata2=cbind(newdata2,factor(scores.clus[[s.name]],levels=fit$xlevels[[pred.name[i]]]))
}else{ newdata2=cbind(newdata2,scores.clus[[s.name]]) }
colnames(newdata2)[dim(newdata2)[2]]=pred.name[i]
}
attack.scores=coef.list[[clus]]$attack
defend.scores=coef.list[[clus]]$defend
bad.attack=fit$xlevels$attack[!detect.normality.outliers(attack.scores)]
bad.defend=fit$xlevels$defend[!detect.normality.outliers(defend.scores)]
if(remove.outliers){
newdata1$attack[newdata1$attack %in% bad.attack]=NA
newdata1$defend[newdata1$defend %in% bad.defend]=NA
newdata2$attack[newdata2$attack %in% bad.attack]=NA
newdata2$defend[newdata2$defend %in% bad.defend]=NA
}
prate=0
for(i in attr(terms(fit),"term.labels")){
prate=prate+coef(object)$coef.list[[clus]][[i]][newdata1[[i]]]
}
home.score=exp(prate)
home.goals = matrix(rpois(n*dim(newdata1)[1],exp(prate)),dim(newdata1)[1],n,byrow=FALSE)
rownames(home.goals)=newdata1$attack
prate=0
for(i in attr(terms(fit),"term.labels")){
prate=prate+coef(object)$coef.list[[clus]][[i]][newdata2[[i]]]
}
away.score=exp(prate)
away.goals = matrix(rpois(n*dim(newdata2)[1],exp(prate)),dim(newdata2)[1],n,byrow=FALSE)
rownames(away.goals)=newdata2$attack
home.attack=attack.scores[match(newdata1$attack,fit$xlevels$attack)]
home.defend=defend.scores[match(newdata2$defend,fit$xlevels$attack)]
away.attack=attack.scores[match(newdata2$attack,fit$xlevels$attack)]
away.defend=defend.scores[match(newdata1$defend,fit$xlevels$attack)]
scores$pred.home.score[rows.clus]=home.score
scores$pred.away.score[rows.clus]=away.score
scores$home.residuals[rows.clus]=scores$home.score[rows.clus]-home.score
scores$away.residuals[rows.clus]=scores$away.score[rows.clus]-away.score
scores$home.attack[rows.clus]=home.attack
scores$home.defend[rows.clus]=home.defend
scores$away.attack[rows.clus]=away.attack
scores$away.defend[rows.clus]=away.defend
home.win=100*apply(home.goals>away.goals,1,sum)/n
away.win=100*apply(away.goals>home.goals,1,sum)/n
tie=100-home.win-away.win
home.shutout=100*apply(home.goals==0,1,sum)/n
away.shutout=100*apply(away.goals==0,1,sum)/n
scores$home.win[rows.clus]=home.win
scores$away.win[rows.clus]=away.win
scores$tie[rows.clus]=tie
scores$home.shutout[rows.clus]=home.shutout
scores$away.shutout[rows.clus]=away.shutout
}
home.goals.sum = c(sum(scores$pred.home.score[!is.na(scores$home.score)],na.rm=TRUE),sum(scores$home.score[!is.na(scores$pred.home.score)],na.rm=TRUE))
away.goals.sum = c(sum(scores$pred.away.score[!is.na(scores$away.score)],na.rm=TRUE),sum(scores$away.score[!is.na(scores$pred.away.score)],na.rm=TRUE))
if(!silent){
exclude.game=is.na(scores$pred.home.score)|is.na(scores$pred.away.score)|is.na(scores$home.score)|is.na(scores$away.score)
n.games=sum(!exclude.game)
pred.home=scores$pred.home.score[!exclude.game]
pred.away=scores$pred.away.score[!exclude.game]
pred.home.wins=pred.home>pred.away
home.wins=scores$home.score[!exclude.game]>scores$away.score[!exclude.game]
pred.away.wins=pred.home<pred.away
away.wins=scores$home.score[!exclude.game]<scores$away.score[!exclude.game]
pred.ties=abs(pred.home-pred.away)<.5
pred.home.wins[pred.ties]=FALSE
pred.away.wins[pred.ties]=FALSE
ties=scores$home.score[!exclude.game]==scores$away.score[!exclude.game]
shutout=as.numeric(scores$home.score[!exclude.game]==0) + as.numeric(scores$away.score[!exclude.game]==0)
if(verbose){
cat("home goals predicted vs actual: ");cat(round(home.goals.sum,digits=1));cat("\n")
cat("away goals predicted vs actual: ");cat(round(away.goals.sum,digits=1));cat("\n")
cat("home wins (predicted vs actual): ");cat(c(round(sum(scores$home.win[!exclude.game])/100,digits=1),sum(home.wins)));cat("\n")
cat("pred ties (predicted vs actual): ");cat(c(round(sum(scores$tie[!exclude.game])/100,digits=1),sum(ties)));cat("\n")
cat("away wins (predicted vs actual): ");cat(c(round(sum(scores$away.win[!exclude.game])/100,digits=1),sum(away.wins)));cat("\n")
cat("pred shutouts (predicted vs actual): ");cat(c(round(sum(scores$home.shutout[!exclude.game])/100,digits=1)+round(sum(scores$away.shutout[!exclude.game])/100,digits=1),sum(shutout)));cat("\n")
cat("correct predictions: "); cat(sum(pred.home.wins+home.wins==2 | pred.ties+ties==2 | pred.away.wins+away.wins==2)/
sum(!exclude.game));cat("\n")
cat("correct home wins: "); cat("fraction: ");cat(sum(pred.home.wins+home.wins==2)/
sum(pred.home.wins));cat(" "); cat("number: "); cat(sum(pred.home.wins+home.wins==2)/
sum(home.wins)); cat("\n")
cat("correct away wins: "); cat(sum(pred.away.wins+away.wins==2)/
sum(pred.away.wins));cat(" "); cat(sum(pred.away.wins+away.wins==2)/
sum(away.wins));cat("\n")
cat("correct ties: "); cat(sum(pred.ties+ties==2)/
sum(pred.ties));cat(" "); cat(sum(pred.ties+ties==2)/
sum(ties));cat("\n")
}
}
if(!silent & show.matches){
for(i in 1:dim(scores)[1]){
if(rnd){
if(!is.na(scores$date[i])) cat(format(scores$date[i],x$date.format));cat(" ")
cat(as.character(scores$home.team[i])); cat(" vs "); cat(as.character(scores$away.team[i]));
cat(", HW ");cat(round(scores$home.win[i]));cat("%, AW ")
cat(round(scores$away.win[i]));cat("%, T "); cat(round(scores$tie[i])); cat("%, pred score ")
cat(round(scores$pred.home.score[i],digits=1)); cat("-");cat(round(scores$pred.away.score[i],digits=1)); cat("");
if(!is.nan(scores$home.score[i]) & !is.nan(scores$away.score[i])){
cat(" actual: ")
if(scores$home.score[i]>scores$away.score[i]) cat("HW")
if(scores$home.score[i]<scores$away.score[i]) cat("AW")
if(scores$home.score[i]==scores$away.score[i]) cat("T")
cat(" ("); cat(scores$home.score[i])
cat("-");cat(scores$away.score[i]); cat(")")
}
cat("\n")
}else{
cat(as.character(scores.clus$home.team[i]));cat(" ");cat(format(home.score[i],digits=2))
cat(" - ");cat(format(away.score[i],digits=2)); cat(" "); cat(as.character(scores.clus$away.team[i])); cat("\n")
}
}
}
invisible(list(scores=scores, home.score=home.score, away.score=away.score, home.goals.sum=home.goals.sum, home.goals=home.goals, away.goals.sum=away.goals.sum, away.goals=away.goals))
}
|
pgamma3 <-
function(q,shape=1,scale=1,thres=0,lower.tail=TRUE,log.p=FALSE)
{
Fx <- pgamma(q-thres,shape,1/scale)
if(!lower.tail) Fx <- 1 - Fx
if(log.p) Fx <- log(Fx)
return(Fx)
}
|
setClass("tidem", contains="oce")
setMethod(f="initialize",
signature="tidem",
definition=function(.Object, ...) {
.Object <- callNextMethod(.Object, ...)
.Object@metadata$version <- ""
.Object@processingLog$time <- presentTime()
.Object@processingLog$value <- "create 'tidem' object"
return(.Object)
})
NULL
NULL
setMethod(f="summary",
signature="tidem",
definition=function(object, p, constituent, ...) {
debug <- if ("debug" %in% names(list(...))) list(...)$debug else 0
version <- object@metadata$version
if (missing(p))
p <- 1
ok <- object@data$p <= p | version == 3
haveP <- any(!is.na(object@data$p))
if (missing(constituent)) {
fit <- data.frame(Const=object@data$const[ok],
Name=object@data$name[ok],
Freq=object@data$freq[ok],
Amplitude=object@data$amplitude[ok],
Phase=object@data$phase[ok],
p=object@data$p[ok])
if (debug) {
cat("For missing(constituent) case, fit is:\n")
print(fit)
}
} else {
i <- NULL
bad <- NULL
for (iconst in seq_along(constituent)) {
w <- which(object@data$name==constituent[iconst])
if (length(w) == 1) {
i <- c(i, w)
} else {
bad <- c(bad, iconst)
}
}
if (length(bad)) {
warning("the following constituents are not handled: '",
paste(constituent[bad], collapse="', '"), "'\n", sep="")
}
if (length(i) == 0)
stop("In summary,tidem-method() : no known constituents were provided", call.=FALSE)
i <- unique(i)
fit <- data.frame(Const=object@data$const[i],
Name=object@data$name[i],
Freq=object@data$freq[i],
Amplitude=object@data$amplitude[i],
Phase=object@data$phase[i],
p=object@data$p[i])
if (debug) {
cat("For !missing(constituent) case, fit is:\n")
print(fit)
}
}
cat("tidem summary\n-------------\n")
if (version != "3") {
cat("\nCall:\n")
cat(paste(deparse(object[["call"]]), sep="\n", collapse="\n"), "\n", sep="")
cat("RMS misfit to data: ", sqrt(var(object[["model"]]$residuals)), '\n')
cat("\nFitted Model:\n")
f <- fit[3:6]
if (debug > 0) {
cat("fit:\n");print(fit)
cat("f:\n");print(f)
}
rownames(f) <- as.character(fit[, 2])
if (haveP) {
printCoefmat(f, digits=3,
signif.stars=getOption("show.signif.stars"),
signif.legend=TRUE,
P.values=TRUE, has.Pvalue=TRUE, ...)
} else {
printCoefmat(f[, -4], digits=3)
}
} else {
cat("\nSupplied Model:\n")
f <- fit[3:5]
rownames(f) <- as.character(fit[, 2])
printCoefmat(f, digits=3)
}
processingLogShow(object)
invisible(NULL)
})
setMethod(f="[[",
signature(x="tidem", i="ANY", j="ANY"),
definition=function(x, i, j, ...) {
if (i == "?")
return(list(metadata=sort(names(x@metadata)),
metadataDerived=NULL,
data=sort(names(x@data)),
dataDerived="frequency"))
if (i == "frequency")
return(x@data$freq)
callNextMethod()
})
setMethod(f="[[<-",
signature(x="tidem", i="ANY", j="ANY"),
definition=function(x, i, j, ..., value) {
callNextMethod(x=x, i=i, j=j, ...=..., value=value)
})
setMethod(f="plot",
signature=signature("tidem"),
definition=function(x,
which=1,
constituents=c("SA", "O1", "K1", "M2", "S2", "M4"),
sides=NULL,
col="blue",
log="",
mgp=getOption("oceMgp"),
mar=c(mgp[1]+1, mgp[1]+1, mgp[2]+0.25, mgp[2]+1),
...)
{
data("tidedata", package="oce", envir=environment())
tidedata <- get("tidedata")
drawConstituent<-function(name="M2", side=3, col="blue", adj=NULL)
{
w <- which(tidedata$const$name == name)
if (!length(w)) {
warning("constituent '", name, "' is unknown")
return()
}
frequency <- tidedata$const$freq[w]
abline(v=frequency, col=col, lty="dotted")
if (par('usr')[1] < frequency && frequency <= par('usr')[2]) {
if (is.null(adj))
mtext(name, side=side, at=frequency, col=col, cex=0.8)
else
mtext(name, side=side, at=frequency, col=col, cex=0.8, adj=adj)
}
}
opar <- par(no.readonly = TRUE)
lw <- length(which)
if (lw > 1) on.exit(par(opar))
par(mgp=mgp, mar=mar)
frequency <- x@data$freq[-1]
amplitude <- x@data$amplitude[-1]
name <- x@data$name[-1]
if (!is.null(constituents)) {
sides <- if (is.null(sides)) rep(3, length(constituents))
else rep(sides, length.out=length(constituents))
col <- rep(col, length.out=length(constituents))
}
sides[sides!=1&sides!=3] <- 3
for (w in 1:lw) {
if (which[w] == 2) {
plot(frequency, amplitude, col="white", xlab="Frequency [ cph ]", ylab="Amplitude [ m ]", log=log)
segments(frequency, 0, frequency, amplitude)
for (i in seq_along(constituents))
drawConstituent(constituents[i], side=sides[i], col=col[i])
} else if (which[w] == 1) {
plot(frequency, cumsum(amplitude), xlab="Frequency [ cph ]", ylab="Amplitude [ m ]", log=log, type='s')
for (i in seq_along(constituents))
drawConstituent(constituents[i], side=sides[i], col=col[i])
} else {
stop("unknown value of which ", which, "; should be 1 or 2")
}
}
if (!all(is.na(pmatch(names(list(...)), "main")))) title(...)
})
as.tidem <- function(tRef, latitude, name, amplitude, phase, debug=getOption("oceDebug"))
{
oceDebug(debug, "as.tidem() {\n", sep="", unindent=1)
if (missing(tRef))
stop("tRef must be given")
if (missing(latitude))
stop("latitude must be given")
if (missing(name))
stop("name must be given")
if (missing(amplitude))
stop("amplitude must be given")
if (missing(phase))
stop("phase must be given")
nname <- length(name)
if (nname != length(amplitude))
stop("lengths of name and amplitude must be equal but they are ", nname, " and ", length(amplitude))
if (nname != length(phase))
stop("lengths of name and phase must be equal but they are ", nname, " and ", length(phase))
data("tidedata", package="oce", envir=environment())
tidedata <- get("tidedata")
tRef <- numberAsPOSIXct(3600 * round(as.numeric(tRef, tz="UTC") / 3600), tz="UTC")
oceDebug(debug, "input head(name): ", paste(head(name), collapse=" "), "\n")
oceDebug(debug, "input head(phase): ", paste(head(phase), collapse=" "), "\n")
oceDebug(debug, "input head(amplitude): ", paste(head(amplitude), collapse=" "), "\n")
freq <- rep(NA, nname)
indices <- rep(NA, nname)
ibad <- NULL
for (i in seq_along(name)) {
oceDebug(debug, "adjusting amplitude and phase for constituent '", name[i], "'\n", sep="")
j <- which(tidedata$const$name==name[i])
oceDebug(debug, " inferred j=", j, " from constituent name\n", sep="")
if (length(j)) {
vuf <- tidemVuf(tRef, j=j, latitude=latitude)
oceDebug(debug, " inferred vuf=", deparse(vuf), "\n")
indices[i] <- j
amplitude[i] <- amplitude[i] * vuf$f
phase[i] <- phase[i] - (vuf$v+vuf$u)*360
freq[i] <- tidedata$const$freq[j]
} else {
ibad <- c(ibad, i)
}
}
if (length(ibad)) {
warning("the following constituents are not handled: '", paste(name[ibad], collapse="', '"), "'\n", sep="")
indices <- indices[-ibad]
name <- name[-ibad]
amplitude <- amplitude[-ibad]
phase <- phase[-ibad]
freq <- freq[-ibad]
}
oceDebug(debug, "after vuf correction, head(name): ", paste(head(name), collapse=" "), "\n")
oceDebug(debug, "after vuf correction, head(phase): ", paste(head(phase), collapse=" "), "\n")
oceDebug(debug, "after vuf correction, head(amplitude): ", paste(head(amplitude), collapse=" "), "\n")
oceDebug(debug, "}
phase <- phase %% 360
res <- new('tidem')
res@data <- list(tRef=tRef,
const=indices,
name=name,
freq=freq,
amplitude=amplitude,
phase=phase,
p=rep(NA, length(name)))
res@metadata$version <- 3
res@processingLog <- processingLogAppend(res@processingLog, paste(deparse(match.call()), sep="", collapse=""))
oceDebug(debug, "}
res
}
tidemVuf <- function(t, j, latitude=NULL)
{
debug <- 0
if (length(t) > 1)
stop("t must be a single POSIXct item")
data("tidedata", package="oce", envir=environment())
tidedata <- get("tidedata")
a <- tidemAstron(t)
if (debug > 0) print(a)
doodson <- cbind(tidedata$const$d1,
tidedata$const$d2,
tidedata$const$d3,
tidedata$const$d4,
tidedata$const$d5,
tidedata$const$d6)
oceDebug(debug,
"doodson[1,]=", doodson[1, ], "\n",
"doodson[2,]=", doodson[2, ], "\n",
"doodson[3,]=", doodson[3, ], "\n")
v <- doodson %*% a$astro + tidedata$const$semi
oceDebug(debug, "tidedata$const$semi[", j, "]=", tidedata$const$semi[j], "\n")
v <- v - trunc(v)
oceDebug(debug, "v[1:3]=", v[1:3], "\n")
if (!is.null(latitude) && !is.na(latitude)) {
if (abs(latitude) < 5) latitude <- sign(latitude) * 5
slat <- sin(pi * latitude / 180)
k <- which(tidedata$sat$ilatfac == 1)
rr <- tidedata$sat$amprat
rr[k] <- rr[k] * 0.36309 * (1.0 - 5.0 * slat * slat) / slat
k <- which(tidedata$sat$ilatfac == 2)
rr[k] <- rr[k] * 2.59808 * slat
uu <- tidedata$sat$deldood %*% a$astro[4:6] + tidedata$sat$phcorr
uu <- uu - trunc(uu)
oceDebug(debug, "uu[1:3]=", uu[1:3], "\n")
nsat <- length(tidedata$sat$iconst)
oceDebug(debug,
"tidedata$sat$iconst=", tidedata$sat$iconst, "\n",
"length(sat$iconst)=", length(tidedata$sat$iconst), "\n")
fsum.vec <- vector("numeric", nsat)
u.vec <- vector("numeric", nsat)
for (isat in 1:nsat) {
oceDebug(debug, "isat=", isat, "\n")
use <- tidedata$sat$iconst == isat
fsum.vec[isat] <- 1 + sum(rr[use] * exp(1i * 2 * pi * uu[use]))
u.vec[isat] <- Arg(fsum.vec[isat]) / 2 / pi
if (isat==8 && debug > 0) {
cat("TEST at isat=8:\n")
cat("fsum.vec[", isat, "]=", fsum.vec[isat], " (EXPECT 1.18531604917590 - 0.08028013402313i)\n")
cat("u.vec[ ", isat, "]=", u.vec[isat], " (EXPECT -0.01076294959868)\n")
}
}
oceDebug(debug,
"uvec[", j, "]=", u.vec[j], "\n",
"fsum.vec[", j, "]=", fsum.vec[j], "\n")
f <- abs(fsum.vec)
u <- Arg(fsum.vec)/2/pi
oceDebug(debug, "f=", f, "\n")
oceDebug(debug, "u=", u, "\n")
for (k in which(!is.na(tidedata$const$ishallow))) {
ik <- tidedata$const$ishallow[k] + 0:(tidedata$const$nshallow[k] - 1)
f[k] <- prod(f[tidedata$shallow$iname[ik]]^abs(tidedata$shallow$coef[ik]))
u[k] <- sum(u[tidedata$shallow$iname[ik]]*tidedata$shallow$coef[ik])
v[k] <- sum(v[tidedata$shallow$iname[ik]]*tidedata$shallow$coef[ik])
if (debug>0 && k < 28)
cat("k=", k, "f[k]=", f[k], " u[k]=", u[k], "v[k]=", v[k], "\n")
}
u <- u[j]
v <- v[j]
f <- f[j]
} else {
v <- v[j]
u <- rep(0, length(j))
f <- rep(1, length(j))
}
if (length(v) < length(u)) {
warning("trimming u and f to get same length as v -- this is a bug")
u <- u[seq_along(v)]
f <- f[seq_along(v)]
}
list(v=v, u=u, f=f)
}
tidemAstron <- function(t)
{
if (length(t) > 1)
stop("t must be a single POSIXct item")
debug <- FALSE
if (is.numeric(t))
t <- numberAsPOSIXct(t, tz="UTC")
d <- as.numeric(difftime(t, ISOdatetime(1899, 12, 31, 12, 0, 0, tz="UTC"), units="days"))
D <- d / 10000
a <- matrix(c(1.0, d, D^2, D^3), ncol=1)
oceDebug(debug, "d=", formatC(d, digits=10), "D=", D, "a=", a, "\n")
scHcPcNpPp <-
matrix(c(270.434164, 13.1763965268, -0.0000850, 0.000000039,
279.696678, 0.9856473354, 0.00002267, 0.000000000,
334.329556, 0.1114040803, -0.0007739, -0.00000026,
-259.183275, 0.0529539222, -0.0001557, -0.000000050,
281.220844, 0.0000470684, 0.0000339, 0.000000070),
nrow=5, ncol=4, byrow=TRUE)
astro <- ( (scHcPcNpPp %*% a) / 360 ) %% 1
oceDebug(debug, "astro=", astro, "\n")
rem <- as.numeric(difftime(t, trunc.POSIXt(t, units="days"), tz="UTC", units="days"))
oceDebug(debug, "rem2=", rem, "\n")
tau <- rem + astro[2, 1] - astro[1, 1]
astro <- c(tau, astro)
da <- matrix(c(0.0, 1.0, 2e-4*D, 3e-4*D^2), nrow=4, ncol=1)
ader <- (scHcPcNpPp %*% da) / 360
dtau <- 1 + ader[2, 1] - ader[1, 1]
ader <- c(dtau, ader)
list(astro=astro, ader=ader)
}
tidemConstituentNameFix <- function(names, debug=1)
{
if ("MS" %in% names) {
if (debug)
warning("constituent name switched from T-TIDE 'MS' to Foreman (1978) 'M8'")
names[names == "MS"] <- "M8"
}
if ("-MS" %in% names) {
if (debug)
warning("removed-constituent name switched from T-TIDE 'MS' to Foreman (1978) 'M8'")
names[names == "-MS"] <- "-M8"
}
if ("UPSI" %in% names) {
if (debug)
warning("constituent name switched from T-TIDE 'UPSI' to Foreman (1978) 'UPS1'")
names[names == "UPSI"] <- "UPS1"
}
if ("-UPSI" %in% names) {
if (debug)
warning("removed-constituent name switched from T-TIDE 'UPSI' to Foreman (1978) 'UPS1'")
names[names == "-UPSI"] <- "-UPS1"
}
names
}
tidem <- function(t, x, constituents, infer=NULL,
latitude=NULL, rc=1, regress=lm,
debug=getOption("oceDebug"))
{
oceDebug(debug, "tidem(t, x,\n", sep="", unindent=1)
oceDebug(debug, " constituents=", if (missing(constituents)) "(missing)" else paste("c('", paste(constituents, collapse="', '"), "')", sep=""), ",\n", sep="", unindent=1)
oceDebug(debug, " latitude=", if (is.null(latitude)) "NULL" else latitude, ",\n", sep="", unindent=1)
oceDebug(debug, " rc=", rc, ",\n", sep="", unindent=1)
oceDebug(debug, " debug=", debug, ") {\n", sep="", unindent=1)
cl <- match.call()
if (missing(t))
stop("must supply 't', either a vector of times or a sealevel object")
if (inherits(t, "sealevel")) {
sl <- t
t <- sl[["time"]]
x <- sl[["elevation"]]
if (is.null(latitude))
latitude <- sl[["latitude"]]
} else {
if (missing(x))
stop("must supply 'x', since the first argument is not a sealevel object")
if (inherits(x, "POSIXt")) {
warning("tidem() switching first 2 args to permit old-style usage")
tmp <- x
x <- t
t <- tmp
}
if (length(x) != length(t))
stop("lengths of 'x' and 't' must match, but they are ", length(x), " and ", length(t), " respectively")
if (inherits(t, "POSIXt")) {
t <- as.POSIXct(t)
} else {
stop("t must be a vector of POSIXt times")
}
sl <- as.sealevel(x, t)
}
data("tidedata", package="oce", envir=environment())
tidedata <- get("tidedata")
tc <- tidedata$const
ntc <- length(tc$name)
if (!is.null(infer)) {
if (!is.list(infer))
stop("infer must be a list")
if (length(infer) != 4)
stop("infer must hold 4 elements")
if (!all.equal(sort(names(infer)), c("amp", "from", "name", "phase")))
stop("infer must contain 'name', 'from', 'amp', and 'phase', and nothing else")
if (!is.character(infer$name))
stop("infer$name must be a vector of character strings")
infer$name <- tidemConstituentNameFix(infer$name)
if (!is.character(infer$from))
stop("infer$from must be a vector of character strings")
infer$from <- tidemConstituentNameFix(infer$from)
if (length(infer$name) != length(infer$from))
stop("lengths of infer$name and infer$from must be equal")
if (length(infer$name) != length(infer$amp))
stop("lengths of infer$name and infer$amp must be equal")
if (length(infer$name) != length(infer$phase))
stop("lengths of infer$name and infer$phase must be equal")
for (n in infer$name) {
if (!(n %in% tc$name))
stop("infer$name value '", n, "' is not a known tidal constituent; see const$name in ?tidedata")
}
for (n in infer$from) {
if (!(n %in% tc$name))
stop("infer$from value '", n, "' is not a known tidal constituent; see const$name in ?tidedata")
}
}
startTime <- t[1]
endTime <- tail(t, 1)
years <- as.numeric(difftime(endTime, startTime, units="secs")) / 86400 / 365.25
if (years > 18.6)
warning("Time series spans 18.6 years, but tidem() is ignoring this important fact")
standard <- tc$ikmpr > 0
addedConstituents <- NULL
if (missing(constituents)) {
name <- tc$name[standard]
freq <- tc$freq[standard]
kmpr <- tc$kmpr[standard]
indices <- seq(1:ntc)[standard]
oceDebug(debug, "starting with ", length(name), " default constituents: ", paste(name, collapse=" "), sep="", "\n")
} else {
name <- NULL
for (i in seq_along(constituents)) {
if (constituents[i] == "standard") {
if (i != 1)
stop("\"standard\" must occur first in constituents list")
name <- tc$name[standard]
} else {
constituents <- tidemConstituentNameFix(constituents)
if (substr(constituents[i], 1, 1) == "-") {
nameRemove <- substr(constituents[i], 2, nchar(constituents[i]))
if (1 != sum(tc$name == nameRemove))
stop("'", nameRemove, "' is not a known tidal constituent; try one of: ",
paste(tc$name, collapse=" "))
remove <- which(name == nameRemove)
oceDebug(debug > 1, "removed '", nameRemove, "'\n", sep="")
if (0 == length(remove))
warning("'", nameRemove, "' is not in the list of constituents currently under study", sep="")
else
name <- name[-remove]
} else {
add <- which(tc$name == constituents[i])
if (1 != length(add))
stop("'", constituents[i], "' is not a known tidal constituent (line 1093)")
if (!(constituents[i] %in% name)) {
name <- c(name, tc$name[add])
addedConstituents <- c(addedConstituents, add)
}
}
}
}
}
oceDebug(debug, "will fit for ", length(name), " constituents: ", paste(name, collapse=" "), "\n", sep="")
fitForZ0 <- "Z0" %in% name
oceDebug(debug, "fitForZ0=", fitForZ0, "\n")
if (any(!(name %in% tc$name))) {
bad <- NULL
for (n in name)
if (!(n %in% tc$name))
bad <- c(bad, n)
stop("unknown constituent names: ", paste(bad, collapse=" "), " (please report this error to developer)")
}
indices <- sort(unlist(lapply(name,function(name) which(tc$name==name))))
name <- tc$name[indices]
freq <- tc$freq[indices]
kmpr <- tc$kmpr[indices]
nc <- length(name)
interval <- diff(range(as.numeric(sl@data$time), na.rm=TRUE)) / 3600
oceDebug(debug, "interval=", interval, " hours\n")
dropTerm <- NULL
for (i in 1:nc) {
cc <- which(tc$name == kmpr[i])
if (length(cc)) {
cannotFit <- (interval * abs(freq[i]-tc$freq[cc])) < rc
oceDebug(debug, "i=", i, ", name=", name[i], ", kmpr[", i, "]=", kmpr[i],", cannotFit=", cannotFit,"\n", sep="")
if (cannotFit) {
dropTerm <- c(dropTerm, i)
}
}
}
oceDebug(debug, "before trimming constituents for Rayleigh condition, name[1:", length(name), "]=", paste(name, collapse=" "), sep="", "\n")
if (length(dropTerm) > 0) {
cat("Note: the tidal record is too short to fit for constituents: ", paste(name[dropTerm], collapse=" "), "\n")
indices <- indices[-dropTerm]
name <- name[-dropTerm]
freq <- freq[-dropTerm]
kmpr <- kmpr[-dropTerm]
}
oceDebug(debug, "after trimming constituents for Rayleight condition, name[1:", length(name), "]=", paste(name, collapse=" "), sep="", "\n")
if (length(addedConstituents)) {
oceDebug(debug, "addedConstituents=", paste(addedConstituents, collapse=" "), "\n")
for (a in addedConstituents) {
if (!(tc$name[a] %in% name)) {
message("ADDING:")
message(" tc$name[a=", a, "]='", tc$name[a], "'", sep="")
message(" tc$freq[a=", a, "]='", tc$freq[a], "'", sep="")
message(" tc$kmpr[a=", a, "]='", tc$kmpr[a], "'", sep="")
indices <- c(indices, which(tc$name==name[a]))
name <- c(name, tc$name[a])
freq <- c(freq, tc$freq[a])
kmpr <- c(kmpr, tc$kmpr[a])
}
}
}
oceDebug(debug, "after adding new constituents, name[1:", length(name), "]=", paste(name, collapse=" "), sep="", "\n")
if (!is.null(infer)) {
for (n in c(infer$from)) {
if (!(n %in% name)) {
a <- which(tc$name == n)
indices <- c(indices, a)
name <- c(name, tc$name[a])
freq <- c(freq, tc$freq[a])
kmpr <- c(kmpr, tc$kmpr[a])
message("fitting for infer$from=", n, ", even though the Rayleigh Criterion would exclude it")
}
}
}
oindices <- order(indices)
indices <- indices[oindices]
name <- name[oindices]
freq <- freq[oindices]
kmpr <- kmpr[oindices]
nc <- length(name)
oceDebug(debug, "name[1:", length(name), "]: ", paste(name, collapse=" "), "\n", sep="")
rm(oindices)
if (0 == nc)
stop("cannot fit for any constituents")
elevation <- sl[["elevation"]]
time <- sl[["time"]]
nt <- length(elevation)
x <- array(dim=c(nt, 2 * nc))
oceDebug(debug, vectorShow(nc))
oceDebug(debug, vectorShow(dim(x)))
x[, 1] <- rep(1, nt)
pi <- 4 * atan2(1, 1)
rpd <- atan2(1, 1) / 45
tRef <- numberAsPOSIXct(3600 * round(mean(as.numeric(time, tz="UTC")) / 3600), tz="UTC")
hour2pi <- 2 * pi * (as.numeric(time) - as.numeric(tRef)) / 3600
oceDebug(debug, "tRef=", tRef, ", nc=", nc, ", length(name)=", length(name), "\n")
for (i in 1:nc) {
oceDebug(debug, "setting ", i, "-th coefficient (name=", name[i], " freq=", freq[i], " cph)", "\n", sep="")
ft <- freq[i] * hour2pi
x[, 1 + 2*(i-1)] <- cos(ft)
x[, 2 + 2*(i-1)] <- sin(ft)
}
name2 <- matrix(rbind(paste(name, "_C", sep=""), paste(name, "_S", sep="")), nrow=length(name), ncol=2)
dim(name2) <- c(2 * length(name), 1)
colnames(x) <- name2
oceDebug(debug, "about to do regression\n")
if ("Z0_S" %in% colnames(x)) {
x <- x[, -which("Z0_S" == colnames(x))]
oceDebug(debug, "model has Z0, so trimming the sin(freq*time) column\n")
}
if (debug) {
cat("x[,1]:\n");print(x[,1])
cat("x[,2]:\n");print(x[,2])
}
model <- regress(elevation ~ x - 1, na.action=na.exclude)
if (debug > 0) {
cat("regression worked OK; the results are as follows:\n")
print(summary(model))
}
coef <- model$coefficients
p.all <- if (4 == dim(summary(model)$coefficients)[2])
summary(model)$coefficients[, 4]
else
rep(NA, length=1+nc)
amplitude <- phase <- p <- vector("numeric", length=nc)
oceDebug(debug, vectorShow(nc))
oceDebug(debug, vectorShow(phase))
oceDebug(debug, vectorShow(name))
ic <- 1
for (i in seq_len(nc)) {
if (name[i] == "Z0") {
if (i != 1)
stop("Z0 should be at the start of the regression coefficients. Please report this to developer.")
j <- which(tidedata$const$name==name[i])
vuf <- tidemVuf(tRef, j=j, latitude=latitude)
amplitude[i] <- coef[ic]
phase[i] <- 0
p[i] <- p.all[ic]
oceDebug(debug, "processed coefs at i=", i, ", ic=", ic, ", name=", name[i], ", f=", vuf$f, ", angle adj=", (vuf$u+vuf$v)*360, ", amplitude=", amplitude[i], ", phase=", phase[i], ", p=", p[i], "\n", sep="")
ic <- ic + 1
} else {
C <- coef[ic]
S <- coef[ic+1]
amplitude[i] <- sqrt(S^2 + C^2)
phase[i] <- atan2(S, C)
j <- which(tidedata$const$name==name[i])
vuf <- tidemVuf(tRef, j=j, latitude=latitude)
amplitude[i] <- amplitude[i] / vuf$f
p[i] <- 0.5 * (p.all[ic+1] + p.all[ic])
oceDebug(debug, "processed coefs at i=", i, ", ic=", ic, ", name=", name[i], ", S=", S, ", C=", C, ", f=", vuf$f, ", angle adj=", (vuf$u+vuf$v)*360, ", amplitude=", amplitude[i], ", phase=", phase[i], ", p=", p[i], "\n", sep="")
ic <- ic + 2
}
}
oceDebug(debug, vectorShow(phase))
phase <- phase * 180 / pi
phase <- ifelse(phase < -360, 720 + phase, phase)
phase <- ifelse(phase < 0, 360 + phase, phase)
C <- unlist(lapply(name, function(n) which(n == tidedata$const$name)))
vuf <- tidemVuf(tRef, j=C, latitude=latitude)
oceDebug(debug, vectorShow(freq))
oceDebug(debug, vectorShow(phase))
oceDebug(debug, vectorShow(vuf$u))
oceDebug(debug, vectorShow(vuf$v))
phase <- phase + (vuf$v+vuf$u)*360
phase <- ifelse(phase < 0, phase+360, phase)
phase <- ifelse(phase > 360, phase-360, phase)
if (!is.null(infer)) {
if (debug > 0) {
cat("BEFORE inference:\n")
print(data.frame(name=name, freq=round(freq,6), amplitude=round(amplitude,4)))
}
for (n in seq_along(infer$name)) {
oceDebug(debug, "n=", n, "; handling inferred constituent ", infer$name[n], "\n")
iname <- which(tc$name == infer$name[n])[1]
oceDebug(debug, "infer$name[", n, "]='", infer$name[n], "' yields iname=", iname, "\n", sep="")
oceDebug(debug, "iname=", iname, "\n")
if (infer$from[n] %in% name) {
ifrom <- which(name == infer$from[n])[1]
if (infer$name[n] %in% name) {
iname <- which(name == infer$name[n])[1]
amplitude[iname] <- infer$amp[n] * amplitude[ifrom]
phase[iname] <- phase[ifrom] - infer$phase[n]
p[iname] <- p[ifrom]
oceDebug(debug, "replace existing ", name[iname], " based on ", name[ifrom], " (", freq[ifrom], " cph)\n", sep="")
warning("inferring '", infer$name[n], "' which is already included in the regression. Foreman says to skip it; unsure on what T_TIDE does\n")
} else {
i1 <- which(tc$name==infer$from[n])[1]
i2 <- which(tc$name==infer$name[n])[1]
oceDebug(1+debug, "tRef=", format(tRef, "%Y-%m-%d %H:%M:%S"),
", i1=", i1, ", i2=", i2, ", lat=", latitude, "\n")
vuf12 <- tidemVuf(tRef, c(i1, i2), latitude=latitude)
f1 <- vuf12$f[1]
f2 <- vuf12$f[2]
oceDebug(1+debug, "f1=", f1, ", f2=", f2, "\n")
vu1 <- (vuf12$v[1] + vuf12$u[1]) * 360
vu2 <- (vuf12$v[2] + vuf12$u[2]) * 360
oceDebug(debug, "vu1=", vu1, ", vu2=", vu2, "\n")
sigma1 <- tc$freq[i1]
sigma2 <- tc$freq[i2]
oceDebug(debug, "sigma1=", sigma1, ", sigma2=", sigma2, "\n")
tmp <- pi * interval * (sigma2 - sigma1)
r12 <- infer$amp[n]
zeta <- infer$phase[n]
S <- r12 * (f2/f1) * sin(tmp) * sin(rpd*(vu2-vu1+zeta)) / tmp
C <- 1 + r12 * (f2/f1) * sin(tmp) * cos(rpd*(vu2-vu1+zeta)) / tmp
oceDebug(debug, "tmp=", tmp, ", S=", S, ", C=", C, ", sqrt(S^2+C^2)=", sqrt(S^2+C^2), "\n")
oceDebug(1+debug, infer$from[n], "amplitude, old=", amplitude[ifrom], ", new=", amplitude[ifrom]/sqrt(S^2+C^2), "\n")
amplitude[ifrom] <- amplitude[ifrom] / sqrt(S^2+C^2)
oceDebug(1+debug, infer$from[n], "phase, old=", phase[ifrom], ", new=", phase[ifrom]+atan2(S, C) / rpd, "\n")
phase[ifrom] <- phase[ifrom] + atan2(S, C) / rpd
iname <- which(tc$name == infer$name[n])[1]
oceDebug(1+debug, "Below is inference for ", infer$name[n], " (index=", iname, ")\n")
indices <- c(indices, iname)
name <- c(name, infer$name[n])
freq <- c(freq, tc$freq[iname])
amplitudeInferred <- infer$amp[n] * amplitude[ifrom]
phaseInferred <- phase[ifrom] - infer$phase[n]
oceDebug(1+debug, " ", infer$name[n], "inferred amplitude=", amplitudeInferred, "\n")
oceDebug(1+debug, " ", infer$name[n], "inferred phase=", phaseInferred, "\n")
amplitude <- c(amplitude, amplitudeInferred)
phase <- c(phase, phaseInferred)
p <- c(p, p[ifrom])
oceDebug(1+debug, " create ", infer$name[n], " (index=", iname, ", ", tc$freq[iname], " cph) based on ", name[ifrom], " (index ", ifrom, ", ", freq[ifrom], " cph)\n", sep="")
}
} else {
stop("Internal error (please report): cannot infer ", infer$name[n], " from ", infer$from[n], " because the latter was not computed")
}
}
o <- order(indices)
indices <- indices[o]
stopifnot(length(o)==length(name))
stopifnot(length(o)==length(freq))
stopifnot(length(o)==length(amplitude))
stopifnot(length(o)==length(phase))
stopifnot(length(o)==length(p))
name <- name[o]
freq <- freq[o]
amplitude <- amplitude[o]
phase <- phase[o]
p <- p[o]
rm(o)
if (debug > 0) {
cat("AFTER inference\n")
print(data.frame(name=name, freq=round(freq,5), amplitude=round(amplitude,4)))
}
}
phase <- phase %% 360
res <- new('tidem')
res@data <- list(model=model,
call=cl,
tRef=tRef,
const=indices,
name=name,
freq=freq,
amplitude=amplitude,
phase=phase,
p=p)
res@metadata$rc <- rc
res@metadata$version <- 2
res@processingLog <- processingLogAppend(res@processingLog, paste(deparse(match.call()), sep="", collapse=""))
oceDebug(debug, "}
res
}
predict.tidem <- function(object, newdata, ...)
{
dots <- list(...)
debug <- if ("debug" %in% names(dots)) dots$debug else 0
oceDebug(debug, "predict.tidem() {\n", sep="", unindent=1)
if (!missing(newdata) && !inherits(newdata, "POSIXt"))
stop("newdata must be of class POSIXt")
version <- object@metadata$version
if (!is.null(version) && version == 3) {
oceDebug(debug, "object@metadata$version is 3, so assuming the object was created by as.tidem()\n")
if (missing(newdata))
stop("must supply newdata because object was created with as.tidem()")
hour2pi <- 2 * pi * (as.numeric(newdata) - as.numeric(object[["tRef"]])) / 3600
oceDebug(debug, vectorShow(hour2pi))
nc <- length(object@data$name)
res <- rep(0, length(hour2pi))
for (i in seq_len(nc)) {
oceDebug(debug, "accounting for constituent[", i, "] = ", object@data$name[i], "\n", sep="")
omega.t <- object@data$freq[i] * hour2pi
a <- object@data$amplitude[i] * sin(2 * pi * object@data$phase[i] / 360)
b <- object@data$amplitude[i] * cos(2 * pi * object@data$phase[i] / 360)
res <- res + a*sin(omega.t) + b*cos(omega.t)
}
} else if (!is.null(version) && version == 2) {
oceDebug(debug, "object@metadata$version is 2, so assuming the object was created by tidem()\n")
if (!missing(newdata) && !is.null(newdata)) {
oceDebug(debug, "newdata was provided\n")
freq <- object@data$freq
name <- object@data$name
nc <- length(freq)
tt <- as.numeric(as.POSIXct(newdata, tz="UTC"))
nt <- length(tt)
x <- array(dim=c(nt, 2 * nc))
x[, 1] <- rep(1, nt)
hour2pi <- 2 * pi * (as.numeric(tt) - as.numeric(object[["tRef"]])) / 3600
for (i in 1:nc) {
omega.t <- freq[i] * hour2pi
x[, 2*i-1] <- cos(omega.t)
x[, 2*i ] <- sin(omega.t)
}
colnames(x) <- matrix(rbind(paste(name, "_C", sep=""), paste(name, "_S", sep="")), nrow=length(name), ncol=2)
if ("Z0_S" %in% colnames(x)) {
x <- x[, -which("Z0_S" == colnames(x))]
oceDebug(debug, "model has Z0, so trimming the sin(freq*time) column\n")
}
res <- as.numeric(predict(object@data$model, newdata=list(x=x), ...))
} else {
oceDebug(debug, "newdata was not provided\n")
res <- as.numeric(predict(object@data$model, ...))
}
} else {
if (!("version" %in% names(object@metadata)))
warning("prediction is being made based on an old object; it may be wrong\n")
res <- as.numeric(predict(object@data$model, ...))
}
oceDebug(debug, "}
res
}
webtide <- function(action=c("map", "predict"),
longitude, latitude, node, time,
basedir=getOption("webtide"),
region="nwatl",
plot=TRUE, tformat, debug=getOption("oceDebug"), ...)
{
debug <- max(0, min(floor(debug), 2))
oceDebug(debug, "webtide(action=\"", action, "\", ...)\n",
sep="", unindent=1, style="bold")
rpd <- atan2(1, 1) / 45
action <- match.arg(action)
nodeGiven <- !missing(node)
longitudeGiven <- !missing(longitude)
latitudeGiven <- !missing(latitude)
path <- paste(basedir, "/data/", region, sep="")
suffices <- c(".nod", "ll.nod", "_ll.nod")
nodFiles <- paste(region, suffices, sep="")
triangles <- NULL
for (nodFile in nodFiles) {
if (1 == length(list.files(path=path, pattern=nodFile))) {
triangles <- read.table(paste(path, nodFile, sep="/"), col.names=c("triangle", "longitude", "latitude"))
oceDebug(debug, "found webtide information in '", nodFile, "'\n", sep="")
break
} else {
oceDebug(debug, "looked for webtide information in '", nodFile, "' but this file does not exist\n", sep="")
}
}
if (is.null(triangles))
stop("cannot find WebTide data file; rerun with debug=1 to see the searched list")
if (action == "map") {
if (plot) {
asp <- 1 / cos(rpd*mean(range(triangles$latitude, na.rm=TRUE)))
par(mfrow=c(1, 1), mar=c(3, 3, 2, 1), mgp=c(2, 0.7, 0))
plot(triangles$longitude, triangles$latitude, pch=2, cex=1/4, lwd=1/8,
asp=asp, xlab="", ylab="", ...)
usr <- par("usr")
bestcoastline <- coastlineBest(lonRange=usr[1:2], latRange=usr[3:4], debug=debug-1)
oceDebug(debug, "coastlineBest() suggests using", bestcoastline, "as the coastline\n")
if (bestcoastline == "coastlineWorld") {
data(list=bestcoastline, package="oce", envir=environment())
coastlineWorld <- get("coastlineWorld")
} else {
if (requireNamespace("ocedata", quietly=TRUE)) {
data(list=bestcoastline, package="ocedata", envir=environment())
oceDebug(debug, "Using", bestcoastline, "from the ocedata package.\n")
coastlineWorld <- get(bestcoastline)
} else {
data(list="coastlineWorld", package="oce", envir=environment())
oceDebug(debug, "The ocedata package is not available, so using", bestcoastline, "from oce\n")
coastlineWorld <- get("coastlineWorld")
}
}
polygon(coastlineWorld[['longitude']], coastlineWorld[['latitude']], col="tan")
if (!nodeGiven && longitudeGiven && latitudeGiven) {
closest <- which.min(geodDist(triangles$longitude, triangles$latitude, longitude, latitude))
node <- triangles$triangle[closest]
}
if (nodeGiven && node < 0 && interactive()) {
point <- locator(1)
node <- which.min(geodDist(triangles$longitude, triangles$latitude, point$x, point$y))
}
if (missing(node)) {
node <- triangles$number
longitude <- triangles$longitude
latitude <- triangles$latitude
} else {
if (is.finite(node)) {
node <- triangles$triangle[node]
longitude <- triangles$longitude[node]
latitude <- triangles$latitude[node]
points(longitude, latitude, pch=20, cex=2, col='blue')
legend("topleft", pch=20, pt.cex=2, cex=3/4, col='blue', bg='white',
legend=sprintf("node %.0f %.3fN %.3fE", node, latitude, longitude))
}
}
oceDebug(debug, "}
return(invisible(list(node=node, latitude=latitude, longitude=longitude)))
} else {
node <- triangles$triangle
longitude <- triangles$longitude
latitude <- triangles$latitude
oceDebug(debug, "}
return(list(node=node, latitude=latitude, longitude=longitude))
}
} else if (action == "predict") {
if (missing(time))
time <- seq.POSIXt(from=presentTime(), by="15 min", length.out=7*4*24)
if (missing(node)) {
if (missing(longitude) || missing(latitude))
stop("'longitude' and 'latitude' must be given unless 'node' is given")
node <- which.min(geodDist(triangles$longitude, triangles$latitude, longitude, latitude))
} else {
latitude <- triangles$latitude[node]
longitude <- triangles$longitude[node]
}
oceDebug(debug, latitude, "N ", longitude, "E -- use node ", node,
" at ", triangles$latitude[node], "N ", triangles$longitude[node], "E\n", sep="")
constituentse <- dir(path=path, pattern="*.s2c")
constituentsuv <- dir(path=path, pattern="*.v2c")
nconstituents <- length(constituentse)
period <- ampe <- phasee <- ampu <- phaseu <- ampv <- phasev <- vector("numeric", length(nconstituents))
data("tidedata", package="oce", envir=environment())
tidedata <- get("tidedata")
for (i in 1:nconstituents) {
twoLetter <- substr(constituentse[i], 1, 2)
C <- which(twoLetter == tidedata$const$name)
period[i] <- 1 / tidedata$const$freq[C]
coneFile <- paste(path, constituentse[i], sep="/")
cone <- read.table(coneFile, skip=3)[node, ]
ampe[i] <- cone[[2]]
phasee[i] <- cone[[3]]
conuvFile <- paste(path, constituentsuv[i], sep="/")
conuv <- read.table(conuvFile, skip=3)[node, ]
ampu[i] <- conuv[[2]]
phaseu[i] <- conuv[[3]]
ampv[i] <- conuv[[4]]
phasev[i] <- conuv[[5]]
oceDebug(debug, coneFile, sprintf("%s ", twoLetter),
sprintf("%4.2fh", period[i]),
sprintf(" (node %d) ", node),
sprintf("%4.4fm ", ampe[i]), sprintf("%3.3fdeg", phasee[i]), "\n", sep="")
}
elevation <- u <- v <- rep(0, length(time))
tRef <- ISOdate(1899, 12, 31, 12, 0, 0, tz="UTC")
h <- (as.numeric(time) - as.numeric(tRef)) / 3600
tRef <- 3600 * round(mean(as.numeric(time)) / 3600)
for (i in 1:nconstituents) {
twoLetter <- substr(constituentse[i], 1, 2)
C <- which(twoLetter == tidedata$const$name)
vuf <- tidemVuf(tRef, j=C, latitude=latitude)
phaseOffset <- (vuf$u + vuf$v) * 360
elevation <- elevation + ampe[i] * cos( (360 * h / period[i] - phasee[i] + phaseOffset) * rpd)
u <- u + ampu[i] * cos( (360 * h / period[i] - phaseu[i] + phaseOffset) * rpd)
v <- v + ampv[i] * cos( (360 * h / period[i] - phasev[i] + phaseOffset) * rpd)
oceDebug(debug, sprintf("%s ", twoLetter),
sprintf("%4.2fh ", period[i]),
sprintf("%4.4fm ", ampe[i]), sprintf("%3.3fdeg", phasee[i]), "\n", sep="")
}
if (plot) {
par(mfrow=c(3, 1))
oce.plot.ts(time, elevation, type='l', xlab="", ylab=resizableLabel("elevation"),
main=sprintf("node %.0f %.3fN %.3fE", node, latitude, longitude),
tformat=tformat)
abline(h=0, lty='dotted', col='gray')
oce.plot.ts(time, u, type='l', xlab="", ylab=resizableLabel("u"),
drawTimeRange=FALSE, tformat=tformat)
abline(h=0, lty='dotted', col='gray')
oce.plot.ts(time, v, type='l', xlab="", ylab=resizableLabel("v"),
drawTimeRange=FALSE, tformat=tformat)
abline(h=0, lty='dotted', col='gray')
oceDebug(debug, "}
return(invisible(list(time=time, elevation=elevation, u=u, v=v,
node=node, basedir=basedir, region=region)))
} else {
oceDebug(debug, "}
return(list(time=time, elevation=elevation, u=u, v=v,
node=node, basedir=basedir, region=region))
}
}
}
|
cophylo<-function(tr1,tr2,assoc=NULL,rotate=TRUE,...){
if(!inherits(tr1,"phylo")||!inherits(tr2,"phylo"))
stop("tr1 & tr2 should be objects of class \"phylo\".")
if(hasArg(methods)) methods<-list(...)$methods
else methods<-"pre"
if("exhaustive"%in%methods) methods<-"exhaustive"
tr1<-untangle(tr1,"read.tree")
tr2<-untangle(tr2,"read.tree")
if(is.null(assoc)){
assoc<-intersect(tr1$tip.label,tr2$tip.label)
assoc<-if(length(assoc)>0) cbind(assoc,assoc) else NULL
if(is.null(assoc)){
cat("No associations provided or found.\n")
rotate<-FALSE
}
}
ii<-sapply(assoc[,1],"%in%",tr1$tip.label)
if(any(!ii)){
assoc<-assoc[ii,]
cat("Some species in assoc[,1] not in tr1. Removing species & links.\n")
}
ii<-sapply(assoc[,2],"%in%",tr2$tip.label)
if(any(!ii)){
assoc<-assoc[ii,]
cat("Some species in assoc[,2] not in tr2. Removing species & links.\n")
}
if(rotate){
cat("Rotating nodes to optimize matching...\n")
flush.console()
if("exhaustive"%in%methods){
tt1<-allRotations(tr1)
tt2<-allRotations(tr2)
M1<-M2<-matrix(NA,length(tt1),length(tt2))
for(i in 1:length(tt1)){
for(j in 1:length(tt2)){
x<-setNames(sapply(assoc[,2],match,table=tt2[[j]]$tip.label),assoc[,1])
y<-setNames(sapply(assoc[,1],match,table=tt1[[i]]$tip.label),assoc[,2])
M1[i,j]<-attr(tipRotate(tt1[[i]],x*Ntip(tr1)/Ntip(tr2),methods="just.compute"),"minRotate")
M2[i,j]<-attr(tipRotate(tt2[[j]],y*Ntip(tr2)/Ntip(tr1),methods="just.compute"),"minRotate")
}
}
MM<-M1+M2
ij<-which(MM==min(MM),arr.ind=TRUE)
obj<-list()
for(i in 1:nrow(ij)){
tr1<-tt1[[ij[i,1]]]
attr(tr1,"minRotate")<-M1[ij[i,1],ij[i,2]]
tr2<-tt2[[ij[i,2]]]
attr(tr2,"minRotate")<-M2[ij[i,1],ij[i,2]]
tt<-list(tr1,tr2)
class(tt)<-"multiPhylo"
obj[[i]]<-list(trees=tt,assoc=assoc)
class(obj[[i]])<-"cophylo"
}
if(length(obj)>1) class(obj)<-"multiCophylo"
else obj<-obj[[1]]
} else if ("all"%in%methods){
tt1<-allRotations(tr1)
tt2<-allRotations(tr2)
obj<-vector(mode="list",length=length(tt1)*length(tt2))
ij<-1
for(i in 1:length(tt1)){
for(j in 1:length(tt2)){
x<-setNames(sapply(assoc[,2],match,table=tt2[[j]]$tip.label),assoc[,1])
y<-setNames(sapply(assoc[,1],match,table=tt1[[i]]$tip.label),assoc[,2])
obj[[ij]]<-list(trees=c(
tipRotate(tt1[[i]],x*Ntip(tr1)/Ntip(tr2),methods="just.compute"),
tipRotate(tt2[[j]],y*Ntip(tr2)/Ntip(tr1),methods="just.compute")),
assoc=assoc)
class(obj[[ij]])<-"cophylo"
ij<-ij+1
}
}
class(obj)<-"multiCophylo"
} else {
x<-setNames(sapply(assoc[,2],match,table=tr2$tip.label),assoc[,1])
tr1<-tipRotate(tr1,x*Ntip(tr1)/Ntip(tr2),right=tr2,assoc=assoc,...)
best.tr1<-Inf
x<-setNames(sapply(assoc[,1],match,table=tr1$tip.label),assoc[,2])
tr2<-tipRotate(tr2,x*Ntip(tr2)/Ntip(tr1),left=tr1,assoc=assoc,...)
best.tr2<-Inf
while((best.tr2-attr(tr2,"minRotate"))>0||(best.tr1-attr(tr1,"minRotate"))>0){
best.tr1<-attr(tr1,"minRotate")
best.tr2<-attr(tr2,"minRotate")
x<-setNames(sapply(assoc[,2],match,table=tr2$tip.label),assoc[,1])
tr1<-tipRotate(tr1,x*Ntip(tr1)/Ntip(tr2),right=tr2,assoc=assoc,...)
x<-setNames(sapply(assoc[,1],match,table=tr1$tip.label),assoc[,2])
tr2<-tipRotate(tr2,x*Ntip(tr2)/Ntip(tr1),left=tr1,assoc=assoc,...)
}
tt<-list(tr1,tr2)
class(tt)<-"multiPhylo"
obj<-list(trees=tt,assoc=assoc)
class(obj)<-"cophylo"
}
cat("Done.\n")
} else {
tt<-list(tr1,tr2)
class(tt)<-"multiPhylo"
obj<-list(trees=tt,assoc=assoc)
class(obj)<-"cophylo"
}
obj
}
phylogram<-function(tree,part=1,direction="rightwards",fsize=1,ftype="i",lwd=1,...){
if(hasArg(pts)) pts<-list(...)$pts
else pts<-TRUE
if(hasArg(edge.col)) edge.col<-list(...)$edge.col
else edge.col<-rep("black",nrow(tree$edge))
if(hasArg(tip.lwd)) tip.lwd<-list(...)$tip.lwd
else tip.lwd<-1
if(hasArg(tip.lty)) tip.lty<-list(...)$tip.lty
else tip.lty<-"dotted"
if(hasArg(tip.len)) tip.len<-list(...)$tip.len
else tip.len<-0.1
if(pts==TRUE&&tip.len==0) tip.len<-0.1
d<-if(direction=="rightwards") 1 else -1
tree$tip.label<-gsub("_"," ",tree$tip.label)
if(is.null(tree$edge.length)) tree<-compute.brlen(tree)
if(ftype=="off") fsize<-0
n<-Ntip(tree)
sh<-fsize*strwidth(tree$tip.label)
H<-nodeHeights(tree)
th<-sapply(1:n,function(i,x,e) x[which(e==i)],x=H[,2],
e=tree$edge[,2])+tip.len*max(H)
tree$edge.length<-tree$edge.length/max(th/(part-sh))
cw<-reorder(tree,"cladewise")
y<-vector(length=n+cw$Nnode)
y[cw$edge[cw$edge[,2]<=n,2]]<-0:(n-1)/(n-1)
pw<-reorder(tree,"pruningwise")
nn<-unique(pw$edge[,1])
for(i in 1:length(nn)){
yy<-y[pw$edge[which(pw$edge[,1]==nn[i]),2]]
y[nn[i]]<-mean(range(yy))
}
X<-nodeHeights(cw)-0.5
for(i in 1:nrow(X)) lines(d*X[i,],rep(y[cw$edge[i,2]],2),lwd=lwd,lend=2,
col=edge.col[i])
for(i in 1:tree$Nnode+n){
ee<-which(cw$edge[,1]==i)
p<-if(i%in%cw$edge[,2]) which(cw$edge[,2]==i) else NULL
if(!is.null(p)){
xx<-c(X[ee,1],X[p,2])
yy<-sort(c(y[cw$edge[ee,2]],y[cw$edge[p,2]]))
} else {
xx<-c(X[ee,1],X[ee[1],1])
yy<-sort(c(y[cw$edge[ee,2]],mean(y[cw$edge[ee,2]])))
}
segments(x0=d*xx[1:(length(xx)-1)],y0=yy[1:(length(yy)-1)],
x1=d*xx[2:length(xx)],y1=yy[2:length(yy)],lwd=lwd,lend=2,col=edge.col[ee])
}
h<-part-0.5-tip.len*(max(X)-min(X))-fsize*strwidth(tree$tip.label)
for(i in 1:n){
lines(d*c(X[which(cw$edge[,2]==i),2],h[i]+tip.len*(max(X)-min(X))),rep(y[i],2),
lwd=tip.lwd,lty=tip.lty)
if(pts) points(d*X[which(cw$edge[,2]==i),2],y[i],pch=16,cex=pts*0.7*sqrt(lwd))
}
font<-which(c("off","reg","b","i","bi")==ftype)-1
if(font>0){
for(i in 1:n) TEXTBOX(d*(h[i]+fsize*strwidth(tree$tip.label[i])+
tip.len*(max(X)-min(X))),y[i],
tree$tip.label[i], pos=if(d<0) 4 else 2,offset=0,
cex=fsize,font=font)
}
PP<-list(type="phylogram",use.edge.length=TRUE,node.pos=1,
show.tip.label=if(ftype!="off") TRUE else FALSE,show.node.label=FALSE,
font=ftype,cex=fsize,adj=0,srt=0,no.margin=FALSE,label.offset=0,
x.lim=par()$usr[1:2],y.lim=par()$usr[3:4],
direction=direction,tip.color="black",Ntip=Ntip(cw),Nnode=cw$Nnode,
edge=cw$edge,xx=d*sapply(1:(Ntip(cw)+cw$Nnode),
function(x,y,z) y[match(x,z)],y=X,z=cw$edge),yy=y)
assign("last_plot.phylo",PP,envir=.PlotPhyloEnv)
invisible(d*max(h+fsize*strwidth(tree$tip.label)+tip.len*(max(X)-min(X))))
}
cladogram<-function(tree,part=1,direction="rightwards",fsize=1,ftype="i",lwd=1,...){
if(hasArg(pts)) pts<-list(...)$pts
else pts<-TRUE
if(hasArg(edge.col)) edge.col<-list(...)$edge.col
else edge.col<-rep("black",nrow(tree$edge))
if(hasArg(tip.lwd)) tip.lwd<-list(...)$tip.lwd
else tip.lwd<-1
if(hasArg(tip.lty)) tip.lty<-list(...)$tip.lty
else tip.lty<-"dotted"
if(hasArg(tip.len)) tip.len<-list(...)$tip.len
else tip.len<-0.1
if(pts==TRUE&&tip.len==0) tip.len<-0.1
d<-if(direction=="rightwards") 1 else -1
tree$tip.label<-gsub("_"," ",tree$tip.label)
if(is.null(tree$edge.length)) tree<-compute.brlen(tree)
if(ftype=="off") fsize<-0
n<-Ntip(tree)
sh<-fsize*strwidth(tree$tip.label)
H<-nodeHeights(tree)
th<-sapply(1:n,function(i,x,e) x[which(e==i)],x=H[,2],
e=tree$edge[,2])+tip.len*max(H)
tree$edge.length<-tree$edge.length/max(th/(part-sh))
cw<-reorder(tree,"cladewise")
y<-vector(length=n+cw$Nnode)
y[cw$edge[cw$edge[,2]<=n,2]]<-0:(n-1)/(n-1)
pw<-reorder(tree,"pruningwise")
nn<-unique(pw$edge[,1])
for(i in 1:length(nn)){
desc<-pw$edge[which(pw$edge[,1]==nn[i]),2]
n1<-desc[which(y[desc]==min(y[desc]))]
n2<-desc[which(y[desc]==max(y[desc]))]
v1<-pw$edge.length[which(pw$edge[,2]==n1)]
v2<-pw$edge.length[which(pw$edge[,2]==n2)]
y[nn[i]]<-((1/v1)*y[n1]+(1/v2)*y[n2])/(1/v1+1/v2)
}
X<-nodeHeights(cw)-0.5
for(i in 1:nrow(X)) lines(d*X[i,],y[cw$edge[i,]],lwd=lwd,lend=2,
col=edge.col[i])
h<-part-0.5-tip.len*(max(X)-min(X))-fsize*strwidth(tree$tip.label)
for(i in 1:n){
lines(d*c(X[which(cw$edge[,2]==i),2],h[i]+tip.len*(max(X)-min(X))),rep(y[i],2),
lwd=tip.lwd,lty=tip.lty)
if(pts) points(d*X[which(cw$edge[,2]==i),2],y[i],pch=16,cex=pts*0.7*sqrt(lwd))
}
font<-which(c("off","reg","b","i","bi")==ftype)-1
if(font>0){
for(i in 1:n) TEXTBOX(d*(h[i]+fsize*strwidth(tree$tip.label[i])+
tip.len*(max(X)-min(X))),y[i],
tree$tip.label[i], pos=if(d<0) 4 else 2,offset=0,
cex=fsize,font=font)
}
PP<-list(type="cladogram",use.edge.length=TRUE,node.pos=1,
show.tip.label=if(ftype!="off") TRUE else FALSE,show.node.label=FALSE,
font=ftype,cex=fsize,adj=0,srt=0,no.margin=FALSE,label.offset=0,
x.lim=par()$usr[1:2],y.lim=par()$usr[3:4],
direction=direction,tip.color="black",Ntip=Ntip(cw),Nnode=cw$Nnode,
edge=cw$edge,xx=d*sapply(1:(Ntip(cw)+cw$Nnode),
function(x,y,z) y[match(x,z)],y=X,z=cw$edge),yy=y)
assign("last_plot.phylo",PP,envir=.PlotPhyloEnv)
invisible(d*max(h+fsize*strwidth(tree$tip.label)+tip.len*(max(X)-min(X))))
}
TEXTBOX<-function(x,y,label,pos,offset,cex,font){
rect(x,y-0.5*strheight(label,cex=cex,font=font),x+if(pos==4) strwidth(label,
cex=cex,font=font) else -strwidth(label,cex=cex,font=font),
y+0.5*strheight(label,cex=cex,font=font),border=FALSE,
col=if(par()$bg%in%c("white","transparent")) "white" else par()$bg)
text(x=x,y=y,label=label,pos=pos,offset=offset,cex=cex,font=font)
}
makelinks<-function(obj,x,link.type="curved",link.lwd=1,link.col="black",
link.lty="dashed"){
if(length(link.lwd)==1) link.lwd<-rep(link.lwd,nrow(obj$assoc))
if(length(link.col)==1) link.col<-rep(link.col,nrow(obj$assoc))
if(length(link.lty)==1) link.lty<-rep(link.lty,nrow(obj$assoc))
for(i in 1:nrow(obj$assoc)){
ii<-which(obj$trees[[1]]$tip.label==obj$assoc[i,1])
jj<-which(obj$trees[[2]]$tip.label==obj$assoc[i,2])
for(j in 1:length(ii)) for(k in 1:length(jj)){
y<-c((ii[j]-1)/(Ntip(obj$trees[[1]])-1),
(jj[k]-1)/(Ntip(obj$trees[[2]])-1))
if(link.type=="straight") lines(x,y,lty=link.lty[i],
lwd=link.lwd[i],col=link.col[i])
else if(link.type=="curved") drawCurve(x,y,lty=link.lty[i],
lwd=link.lwd[i],col=link.col[i])
}
}
}
plot.multiCophylo<-function(x,...){
par(ask=TRUE)
for(i in 1:length(x)) plot.cophylo(x[[i]],...)
}
plot.cophylo<-function(x,...){
plot.new()
if(hasArg(type)) type<-list(...)$type
else type<-"phylogram"
if(hasArg(mar)) mar<-list(...)$mar
else mar<-c(0.1,0.1,0.1,0.1)
if(hasArg(xlim)) xlim<-list(...)$xlim
else xlim<-c(-0.5,0.5)
if(hasArg(scale.bar)) scale.bar<-list(...)$scale.bar
else scale.bar<-rep(0,2)
if(hasArg(ylim)) ylim<-list(...)$ylim
else ylim<-if(any(scale.bar>0)) c(-0.1,1) else c(0,1)
if(hasArg(link.type)) link.type<-list(...)$link.type
else link.type<-"straight"
if(hasArg(link.lwd)) link.lwd<-list(...)$link.lwd
else link.lwd<-1
if(hasArg(link.col)) link.col<-list(...)$link.col
else link.col<-"black"
if(hasArg(link.lty)) link.lty<-list(...)$link.lty
else link.lty<-"dashed"
if(hasArg(edge.col)) edge.col<-list(...)$edge.col
else edge.col<-list(
left=rep("black",nrow(x$trees[[1]]$edge)),
right=rep("black",nrow(x$trees[[2]]$edge)))
obj<-list(...)
if(is.null(obj$part)) obj$part<-0.4
par(mar=mar)
plot.window(xlim=xlim,ylim=ylim)
leftArgs<-rightArgs<-obj
leftArgs$edge.col<-edge.col$left
rightArgs$edge.col<-edge.col$right
if(!is.null(obj$fsize)){
if(length(obj$fsize)>1){
leftArgs$fsize<-obj$fsize[1]
rightArgs$fsize<-obj$fsize[2]
sb.fsize<- if(length(obj$fsize)>2) obj$fsize[3] else 1
} else sb.fsize<-1
} else sb.fsize<-1
plotter<-if(type=="cladogram") "cladogram" else "phylogram"
x1<-do.call(plotter,c(list(tree=x$trees[[1]]),leftArgs))
left<-get("last_plot.phylo",envir=.PlotPhyloEnv)
x2<-do.call(plotter,c(list(tree=x$trees[[2]],direction="leftwards"),
rightArgs))
right<-get("last_plot.phylo",envir=.PlotPhyloEnv)
if(!is.null(x$assoc)) makelinks(x,c(x1,x2),link.type,link.lwd,link.col,
link.lty)
else cat("No associations provided.\n")
if(any(scale.bar>0)) add.scalebar(x,scale.bar,sb.fsize)
assign("last_plot.cophylo",list(left=left,right=right),envir=.PlotPhyloEnv)
}
add.scalebar<-function(obj,scale.bar,fsize){
if(scale.bar[1]>0){
s1<-(0.4-max(fsize*strwidth(obj$trees[[1]]$tip.label)))/max(nodeHeights(obj$trees[[1]]))
lines(c(-0.5,-0.5+scale.bar[1]*s1),rep(-0.05,2))
lines(rep(-0.5,2),c(-0.05,-0.06))
lines(rep(-0.5+scale.bar[1]*s1,2),c(-0.05,-0.06))
text(mean(c(-0.5,-0.5+scale.bar[1]*s1)),rep(-0.05,2),scale.bar[1],pos=1)
}
if(scale.bar[2]>0){
s2<-(0.4-max(fsize*strwidth(obj$trees[[2]]$tip.label)))/max(nodeHeights(obj$trees[[2]]))
lines(c(0.5-scale.bar[2]*s2,0.5),rep(-0.05,2))
lines(rep(0.5-scale.bar[2]*s2,2),c(-0.05,-0.06))
lines(rep(0.5,2),c(-0.05,-0.06))
text(mean(c(0.5-scale.bar[2]*s2,0.5)),rep(-0.05,2),scale.bar[2],pos=1)
}
}
print.cophylo<-function(x, ...){
cat("Object of class \"cophylo\" containing:\n\n")
cat("(1) 2 (possibly rotated) phylogenetic trees in an object of class \"multiPhylo\".\n\n")
cat("(2) A table of associations between the tips of both trees.\n\n")
}
print.multiCophylo<-function(x, ...)
cat("Object of class \"multiCophylo\" containg",length(x),"objects of class \"cophylo\".\n\n")
tipRotate<-function(tree,x,...){
if(hasArg(fn)) fn<-list(...)$fn
else fn<-function(x) x^2
if(hasArg(methods)) methods<-list(...)$methods
else methods<-"pre"
if("exhaustive"%in%methods) methods<-"exhaustive"
if(hasArg(print)) print<-list(...)$print
else print<-FALSE
if(hasArg(max.exhaustive)) max.exhaustive<-list(...)$max.exhaustive
else max.exhaustive<-20
if(hasArg(rotate.multi)) rotate.multi<-list(...)$rotate.multi
else rotate.multi<-FALSE
if(rotate.multi) rotate.multi<-!is.binary(tree)
if(hasArg(anim.cophylo)) anim.cophylo<-list(...)$anim.cophylo
else anim.cophylo<-FALSE
if(anim.cophylo){
if(hasArg(left)) left<-list(...)$left
else left<-NULL
if(hasArg(right)) right<-list(...)$right
else right<-NULL
if(hasArg(assoc)) assoc<-list(...)$assoc
else assoc<-NULL
if(is.null(left)&&is.null(right)) anim.cophylo<-FALSE
if(hasArg(only.accepted)) only.accepted<-list(...)$only.accepted
else only.accepted<-TRUE
}
tree<-reorder(tree)
nn<-1:tree$Nnode+length(tree$tip.label)
if("just.compute"%in%methods){
foo<-function(phy,x) sum(fn(x-setNames(1:length(phy$tip.label),phy$tip.label)[names(x)]))
oo<-pp<-foo(tree,x)
}
if("exhaustive"%in%methods){
if(Ntip(tree)>max.exhaustive){
cat(paste("\nmethods=\"exhaustive\" not permitted for more than",
max.exhaustive,"tips.\n",
"If you are sure you want to run an exhaustive search for a tree of this size\n",
"increasing argument max.exhaustive & re-run.\n",
"Setting methods to \"pre\".\n\n"))
methods<-"pre"
} else {
cat("Running exhaustive search. May be slow!\n")
oo<-Inf
tt<-allRotations(tree)
foo<-function(phy,x) sum(fn(x-setNames(1:length(phy$tip.label),phy$tip.label)[names(x)]))
pp<-sapply(tt,foo,x=x)
ii<-which(pp==min(pp))
ii<-if(length(ii)>1) sample(ii,1) else ii
tt<-tt[[ii]]
pp<-pp[ii]
}
if(print) message(paste("objective:",pp))
tree<-tt
}
ANIM.COPHYLO<-function(tree){
dev.hold()
if(is.null(left)) plot(cophylo(tree,right,assoc=assoc,rotate=FALSE),...)
else if(is.null(right)) plot(cophylo(left,tree,assoc=assoc,rotate=FALSE),...)
nodelabels.cophylo(node=i+Ntip(tree),pie=1,col="red",cex=0.4,
which=if(is.null(left)) "left" else "right")
dev.flush()
}
if("pre"%in%methods){
for(i in 1:tree$Nnode){
if(anim.cophylo) ANIM.COPHYLO(tree)
tt<-if(rotate.multi) rotate.multi(tree,nn[i]) else untangle(rotate(tree,nn[i]),"read.tree")
oo<-sum(fn(x-setNames(1:length(tree$tip.label),tree$tip.label)[names(x)]))
if(inherits(tt,"phylo")) pp<-sum(fn(x-setNames(1:length(tt$tip.label),tt$tip.label)[names(x)]))
if(anim.cophylo&&!only.accepted) ANIM.COPHYLO(tt)
else if(inherits(tt,"multiPhylo")){
foo<-function(phy,x) sum(fn(x-setNames(1:length(phy$tip.label),phy$tip.label)[names(x)]))
pp<-sapply(tt,foo,x=x)
if(anim.cophylo&&!only.accepted) nulo<-lapply(tt,ANIM.COPHYLO)
ii<-which(pp==min(pp))
ii<-if(length(ii)>1) sample(ii,1) else ii
tt<-tt[[ii]]
pp<-pp[ii]
}
if(oo>pp) tree<-tt
if(print) message(paste("objective:",min(oo,pp)))
}
}
if("post"%in%methods){
for(i in tree$Nnode:1){
if(anim.cophylo) ANIM.COPHYLO(tree)
tt<-if(rotate.multi) rotate.multi(tree,nn[i]) else untangle(rotate(tree,nn[i]),"read.tree")
oo<-sum(fn(x-setNames(1:length(tree$tip.label),tree$tip.label)[names(x)]))
if(inherits(tt,"phylo")) pp<-sum(fn(x-setNames(1:length(tt$tip.label),tt$tip.label)[names(x)]))
if(anim.cophylo&&!only.accepted) ANIM.COPHYLO(tt)
else if(inherits(tt,"multiPhylo")){
foo<-function(phy,x) sum(fn(x-setNames(1:length(phy$tip.label),phy$tip.label)[names(x)]))
pp<-sapply(tt,foo,x=x)
if(anim.cophylo&&!only.accepted) nulo<-lapply(tt,ANIM.COPHYLO)
ii<-which(pp==min(pp))
ii<-if(length(ii)>1) sample(ii,1) else ii
tt<-tt[[ii]]
pp<-pp[ii]
}
if(oo>pp) tree<-tt
if(print) message(paste("objective:",min(oo,pp)))
}
}
attr(tree,"minRotate")<-min(oo,pp)
if(anim.cophylo) ANIM.COPHYLO(tree)
tree
}
MULTI2DI<-function(x,...){
obj<-lapply(x,multi2di,...)
class(obj)<-"multiPhylo"
obj
}
nodelabels.cophylo<-function(...,which=c("left","right")){
obj<-get("last_plot.cophylo",envir=.PlotPhyloEnv)
if(which[1]=="left") assign("last_plot.phylo",obj[[1]],envir=.PlotPhyloEnv)
else if(which[1]=="right") assign("last_plot.phylo",obj[[2]],envir=.PlotPhyloEnv)
nodelabels(...)
}
edgelabels.cophylo<-function(...,which=c("left","right")){
obj<-get("last_plot.cophylo",envir=.PlotPhyloEnv)
if(which[1]=="left") assign("last_plot.phylo",obj[[1]],envir=.PlotPhyloEnv)
else if(which[1]=="right") assign("last_plot.phylo",obj[[2]],envir=.PlotPhyloEnv)
edgelabels(...)
}
tiplabels.cophylo<-function(...,which=c("left","right")){
obj<-get("last_plot.cophylo",envir=.PlotPhyloEnv)
if(which[1]=="left") assign("last_plot.phylo",obj[[1]],envir=.PlotPhyloEnv)
else if(which[1]=="right") assign("last_plot.phylo",obj[[2]],envir=.PlotPhyloEnv)
tiplabels(...)
}
drawCurve<-function(x,y,scale=0.01,...){
x1<-x[1]
x2<-x[2]
y1<-y[1]
y2<-y[2]
curve(plogis(x,scale=scale,location=(x1+x2)/2)*(y2-y1)+y1,
x1,x2,add=TRUE,...)
}
summary.cophylo<-function(object,...){
cat("\nCo-phylogenetic (\"cophylo\") object:",deparse(substitute(object)),
"\n\n")
cat(paste("Tree 1 (left tree) is an object of class \"phylo\" containing",
Ntip(object$trees[[1]]),"species.\n\n"))
cat(paste("Tree 2 (right tree) is an object of class \"phylo\" containing",
Ntip(object$trees[[2]]),"species.\n\n"))
cat("Association (assoc) table as follows:\n\n")
maxl<-max(sapply(strsplit(object$assoc[,1],""),length))
cat(paste("\tleft:",paste(rep(" ",max(0,maxl-5)),collapse=""),
"\t----\tright:\n",sep=""))
nulo<-apply(object$assoc,1,function(x,maxl) cat(paste("\t",x[1],
paste(rep(" ",maxl-length(strsplit(x[1],split="")[[1]])),
collapse=""),"\t----\t",x[2],"\n",sep="")),maxl=maxl)
cat("\n")
}
|
is_colour <- function(x)
UseMethod('is_colour', x)
is_colour.character <- function(x)
grepl('
is_colour.numeric <- function(x)
x %in% seq_along(grDevices::palette())
is_colour.logical <- function(x)
is.na(x)
is_colour.factor <- function(x)
is_colour.character(as.character(x))
|
library(knitr)
knitr::opts_chunk$set(echo = TRUE)
library(swmmr)
library(purrr)
library(dplyr)
library(sf)
inp_file <- system.file("extdata", "Example1.inp", package = "swmmr", mustWork = TRUE)
out_dir <- tempdir()
Example1 <- read_inp(x = inp_file)
summary(Example1)
inp_to_files(x = Example1, name = "Example1", path_out = out_dir)
list.files(out_dir)
c("shp", "txt", "dat") %>%
map( ~ file.path(out_dir, .)) %>%
map(list.files)
Example1_con <- shp_to_inp(
path_options = file.path(out_dir,"txt/Example1_options.txt"),
path_timeseries = file.path(out_dir,"dat/Example1_timeseries_TS1.dat"),
path_polygon = file.path(out_dir,"shp/Example1_polygon.shp"),
path_line = file.path(out_dir,"shp/Example1_link.shp"),
path_point = file.path(out_dir,"shp/Example1_point.shp"),
path_outfall = file.path(out_dir,"shp/Example1_outfall.shp")
)
summary(Example1_con)
dir.create(file.path(out_dir, "inp_new"))
write_inp(Example1_con, file.path(out_dir, "inp_new", "Example1_con.inp"))
infiltration <- tibble(
Soil = c("A", "B"),
MaxRate = c(76.2, 127),
MinRate = c(3.81, 7.62),
Decay = c(0.069, 0.069),
DryTime = c(1,1),
MaxInf = c(0,0)
)
subcatchment_typologies <- tibble(
Type = c("Street", "Park"),
Perc_Imperv = c(100, 10),
Width = c(9, 30),
Slope = c(0.57, 1),
CurbLen = 0,
Snowpack = ' ',
Rain_Gage = "Test_rain",
N_Imperv = c(0.01, 0.025),
N_Perv = c(0.01, 0.2),
S_Imperv = c(1.5, 0.58),
S_Perv = c(1.5, 0.58),
Pct_Zero = 0,
PctRouted = 100
)
conduit_material <- tibble(
Material = "B",
Roughness = 0.018
)
junction_parameters <- tibble(
Y = 0,
Ysur = 1,
Apond = 1
)
|
logpb <- function(b, theta, data) {
r <- data$r
q <- data$q
K <- data$K
nk <- data$nk
y <- data$y
X <- data$X
Z <- data$Z
v <- data$v
Z.fail <- data$Z.fail
IW.fail <- data$IW.fail
tj.ind <- data$tj.ind
beta <- theta$beta
gamma <- theta$gamma
sigma2 <- theta$sigma2
haz <- theta$haz
D <- theta$D
if (sum(r) == 1) {
D <- as.matrix(D)
}
if (length(b) != sum(r)) {
stop("Incorrect length of b")
}
if (q > 0) {
gamma.scale <- diag(rep(gamma[-(1:q)], r), ncol = sum(r))
} else {
gamma.scale <- diag(rep(gamma, r), ncol = sum(r))
}
pb <- mvtnorm::dmvnorm(b, mean = rep(0, sum(r)), sigma = D, log = TRUE)
XbetaZb <- as.vector((X %*% beta) + (Z %*% b))
Sigma <- diag(x = rep(sigma2, nk), ncol = sum(nk))
py.b <- mvtnorm::dmvnorm(y, mean = XbetaZb, sigma = Sigma, log = TRUE)
IZ <- t(IW.fail %*% Z.fail)
W2 <- t(b) %*% gamma.scale %*% IZ
if (q > 0) {
W2 <- W2 + as.numeric(t(v) %*% gamma[1:q])
}
W2 <- as.vector(W2)
if (tj.ind > 0) {
pt.b <- -sum(haz[1:tj.ind] * exp(W2))
} else {
pt.b <- 0
}
out <- pt.b + py.b + pb
return(out)
}
b_mode <- function(theta, data) {
out <- optim(par = rep(0, sum(data$r)),
fn = logpb,
theta = theta,
data = data,
control = list(fnscale = -1),
method = "BFGS",
hessian = TRUE)
return(out)
}
b_metropolis <- function(theta.samp, delta.prop, sigma.prop, b.curr, data.t) {
accept <- 0
b.prop <- mvtnorm::rmvt(n = 1,
delta = delta.prop,
sigma = sigma.prop,
df = 4)
b.prop <- as.vector(b.prop)
log.a1 <- logpb(b.prop, theta.samp, data.t) - logpb(b.curr, theta.samp, data.t)
dens.curr <- mvtnorm::dmvt(x = b.curr,
delta = delta.prop,
sigma = sigma.prop,
df = 4,
log = TRUE)
dens.prop <- mvtnorm::dmvt(x = b.prop,
delta = delta.prop,
sigma = sigma.prop,
df = 4,
log = TRUE)
log.a2 <- dens.curr - dens.prop
a <- min(exp(log.a1 - log.a2), 1)
randu <- runif(1)
if (randu <= a) {
b.curr <- b.prop
accept <- 1
}
out <- list("b.curr" = b.curr, "accept" = accept)
return(out)
}
|
coef.svmpath<-function(object,lambda,...){
if(missing(lambda)){
alpha<-object$alpha
lambda<-object$lambda
alpha0<-object$alpha0
}
else{
alphs<-predict(object,lambda=lambda,type="alpha")
alpha<-alphs$alpha
alpha0<-alphs$alpha0
}
alpha<-alpha*object$y
beta<-scale(t(object$x)%*%alpha,FALSE,lambda)
beta0<-alpha0/lambda
list(beta=beta,beta0=beta0,lambda=lambda)
}
|
context(".compOpts")
test_that(".compOpts", {
expect_true(.compOpts("", "cp")$ncharts == 2)
expect_true(.compOpts("", NULL)$ncharts == 1)
expect_true(.compOpts(list(), NULL)$ncharts == 1)
})
if(.requireRhdf5_Antares(stopP = FALSE)){
context(".dateRangeJoin")
test_that(".dateRangeJoin", {
dt <- list()
dt$x <- list(list(dateRange = as.Date(c("2010-01-01", "2010-01-10"))),
list(dateRange = as.Date(c("2010-01-02", "2010-01-09"))))
expect_true(.dateRangeJoin(dt, "union", "min") == as.Date("2010-01-01"))
expect_true(.dateRangeJoin(dt, "union", "max") == as.Date("2010-01-10"))
expect_true(.dateRangeJoin(dt, "intersect", "max") == as.Date("2010-01-09"))
expect_true(.dateRangeJoin(dt, "intersect", "min") == as.Date("2010-01-02"))
dt2 <- list()
dt2$x <- list(list(ar = list(dateRange = as.Date(c("2010-01-01", "2010-01-10")))),
list(ar = list(dateRange = as.Date(c("2010-01-02", "2010-01-09")))))
expect_true(.dateRangeJoin(dt2, "union", "min", "ar") == as.Date("2010-01-01"))
expect_true(.dateRangeJoin(dt2, "union", "max", "ar") == as.Date("2010-01-10"))
expect_true(.dateRangeJoin(dt2, "intersect", "max", "ar") == as.Date("2010-01-09"))
expect_true(.dateRangeJoin(dt2, "intersect", "min", "ar") == as.Date("2010-01-02"))
})
context(".loadH5Data")
test_that(".loadH5Data", {
opts <- setSimulationPath(studyPath)
sharerequest <- list()
sharerequest$mcYearh_l <- "all"
sharerequest$tables_l <- c("areas", "links", "clusters", "districts")
sharerequest$timeSteph5_l <- "hourly"
expect_true("antaresDataList" %in% class(.loadH5Data(sharerequest, opts)))
})
}
|
local_edition(3)
test_that("Correct anchor_sections style is used", {
deps <- html_dependency_anchor_sections
expect_s3_class(deps(), "html_dependency")
expect_error(deps("dummy"), "should be one of")
expect_match(deps()$stylesheet[[2]], "anchor-sections-hash.css")
expect_null(deps()$script[[1]])
expect_equal(deps(section_divs = TRUE)$script[[1]], "anchor-sections.js")
})
test_that("dependency merge is correct", {
prepare_list <- function(lst) {
names(lst) <- NULL
lapply(lst, function(item) {
item[!sapply(item, is.null)]
})
}
test_dep_merge <- function(input, output, doeswarn = FALSE) {
deps <- flatten_html_dependencies(input)
expect_warning(
result <- html_dependency_resolver(deps),
if (doeswarn) NULL else NA
)
result <- prepare_list(result)
output <- prepare_list(output)
expect_identical(result, output)
}
test_dep_merge(
list(
htmlDependency(
name = "foo",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js")),
list(
htmlDependency(
name = "foo",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js")))
test_dep_merge(
list(
htmlDependency(
name = "foo",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "foo",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js")),
list(
htmlDependency(
name = "foo",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js")))
test_dep_merge(
list(
htmlDependency(
name = "foo",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "bar",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js"),
htmlDependency(
name = "bar",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js")),
list(
htmlDependency(
name = "foo",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "bar",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js")))
test_dep_merge(
list(
htmlDependency(
name = "bar",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
list(
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js"),
htmlDependency(
name = "bar",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js"))),
list(
htmlDependency(
name = "bar",
version = "1.2.0",
src = pkg_file("rmd/h"),
script = "foo.js"),
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js")))
test_dep_merge(
list(
structure(list(foo = "irrelevant"), class = "irrelevant"),
list(
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js"))),
list(
htmlDependency(
name = "baz",
version = "1.1.0",
src = pkg_file("rmd/h"),
script = "baz.js")))
})
test_that("Dependencies are correctly validated", {
expect_error(validate_html_dependency(list(a = 1)), "is not of class html_dependency", fixed = TRUE)
skip_if_not_installed("htmltools")
dep <- htmlDependency(name = "foo", version = "1.1.0", src = pkg_file("rmd/h"), script = "foo.js")
expect_identical(validate_html_dependency(dep), dep)
dep <- htmlDependency(name = "foo", version = "1.1.0", src = c(href = "https://example.org"), script = "foo.js")
expect_identical(validate_html_dependency(dep), dep)
dep2 <- dep; dep2$name <- NULL
expect_error(validate_html_dependency(dep2), "name .* not provided")
dep2 <- dep; dep2$version <- NULL
expect_error(validate_html_dependency(dep2), "version .* not provided")
dep2 <- dep; dep2$src <- NULL
expect_error(validate_html_dependency(dep2), "src .* not provided")
dep2 <- dep; dep2$src <- list(file = tempfile("donotexist"))
expect_error(validate_html_dependency(dep2), "path for html_dependency not found:", fixed = TRUE)
})
test_that("html_dependencies_as_string tranforms correctly", {
deps <- list(
htmlDependency(name = "bar", version = "1.2.0", src = pkg_file("rmd/h"), script = "foo.js"),
htmlDependency(name = "bar", version = "1.2.0", src = c(href = "https://example.org/"), script = "foo.js"),
htmlDependency(name = "baz", version = "1.1.0", src = pkg_file("rmd/h"), script = "baz.js")
)
odir <- withr::local_tempdir()
dir.create(ldir <- file.path(odir, "lib"))
expect_snapshot(html_dependencies_as_string(deps, ldir, odir))
})
test_that("html_dependencies_fonts loads the correct fonts dep", {
fa <- html_dependency_font_awesome()
io <- html_dependency_ionicons()
expect_identical(html_dependencies_fonts(TRUE, FALSE), list(fa))
expect_identical(html_dependencies_fonts(FALSE, TRUE), list(io))
expect_identical(html_dependencies_fonts(TRUE, TRUE), list(fa, io))
})
test_that("header-attr can be opt-out", {
withr::local_options(list(rmarkdown.html_dependency.header_attr = FALSE))
expect_null(html_dependency_header_attrs())
})
|
"lesmis"
|
fill_na <- function(Y) {
apply(Y, 2, function(x) {
n_x <- length(x)
if (any(is.na(x))) {
x <- x[1:max(which(is.na(x) == FALSE))]
for (i in which(is.na(x))) {
x1 <- NA
counter <- 1
while (is.na(x1) == TRUE) {
x1 <- x[i + counter]
counter <- counter + 1
}
x[i] <- x1
}
trimmed_length <- length(x)
if (trimmed_length < n_x) {
x <- c(x, rep(NA, n_x - trimmed_length))
for (i in trimmed_length:n_x) {
x[i] <- x[trimmed_length]
}
}
}
x})
}
|
sparsematrix_from_edgelist <- function(
data,
sender_name = NULL,
receiver_name = NULL,
weight_name = NULL,
duplicates = c("add", "remove"),
is_bipartite = T
){
base_weight <- NULL
w <- NULL
. <- NULL
edges <- data.table(data)
if(is.null(sender_name) | is.null(receiver_name)){
id1 = 1
id2 = 2
}else{
id1 = match(sender_name, names(edges))
id2 = match(receiver_name, names(edges))
}
if(is.null(weight_name)){
edges[, base_weight := 1]
weight = match("base_weight", names(edges))
} else{
weight = match(weight_name, names(edges))
}
edges <- edges[, c(id1, id2, weight), with = F]
names(edges) <- c("id1", "id2", "w")
edges[, ':='(
id1 = as.character(id1),
id2 = as.character(id2),
w = as.numeric(as.character(w))
)]
if(duplicates[1] == "add"){
edges <- edges[, .(w = sum(w)), by = list(id1, id2)]
}else(
edges <- edges[!duplicated(paste(id1,id2)), ]
)
if(!is_bipartite){
unique_id1 <- unique(edges$id1)
unique_id2 <- unique(edges$id2)
unique_ids <- unique(c(unique_id1, unique_id2))
if(!(all(unique_id1 %in% unique_id2) & all(unique_id2 %in% unique_id1))){
edges <- rbind(edges, data.table(id1 = unique_ids, id2 = unique_ids, w = 0))
}
}
if(is_bipartite){
edges[, ':='(
id1 = as.numeric(factor(id1, levels = unique(as.character(id1)))),
id2 = as.numeric(factor(id2, levels = unique(as.character(id2))))
)]
}else{
edges[, ':='(
id1 = as.numeric(factor(id1, levels = unique_ids)),
id2 = as.numeric(factor(id2, levels = unique_ids))
)]
}
adj_mat <- sparseMatrix(i = edges$id1, j = edges$id2, x = edges$w)
adj_mat <- drop0(adj_mat)
return(adj_mat)
}
|
SaturationFilter_F <- function(train, test, seed=-1){
alg <- RKEEL::R6_SaturationFilter_F$new()
alg$setParameters(train, test, seed)
return (alg)
}
R6_SaturationFilter_F <- R6::R6Class("R6_SaturationFilter_F",
inherit = PreprocessAlgorithm,
public = list(
seed = -1,
setParameters = function(train, test, seed=-1){
super$setParameters(train, test)
if(seed == -1) {
self$seed <- sample(1:1000000, 1)
}
else {
self$seed <- seed
}
}
),
private = list(
jarName = "Filter-SaturationFilter.jar",
algorithmName = "SaturationFilter-F",
algorithmString = "SaturationFilter",
getParametersText = function(){
text <- ""
text <- paste0(text, "seed = ", self$seed, "\n")
text <- paste0(text, "noiseSensitivity = 0.75", "\n")
return(text)
}
)
)
|
plotWB_lines <- function(WB, cols = c("
interpolator <- match.arg(interpolator)
spline.method <- match.arg(spline.method)
col.ppt <- cols[1]
col.pet <- cols[2]
col.utilization <- cols[3]
if(interpolator == 'linear') {
ppt.interp <- approxfun(WB$month, WB$PPT)
pet.interp <- approxfun(WB$month, WB$PET)
aet.interp <- approxfun(WB$month, WB$ET)
def.interp <- approxfun(WB$month, -WB$D)
}
if(interpolator == 'spline') {
ppt.interp <- splinefun(WB$month, WB$PPT, method = spline.method)
pet.interp <- splinefun(WB$month, WB$PET, method = spline.method)
aet.interp <- splinefun(WB$month, WB$ET, method = spline.method)
def.interp <- splinefun(WB$month, -WB$D, method = spline.method)
}
y.range <- range(c(WB$PET, WB$PPT))
month.start <- WB$month[1]
month.end <- WB$month[12]
month.seq <- seq(from=month.start, to=month.end, by=0.1)
ppt.seq <- pmax(ppt.interp(month.seq), 0)
pet.seq <- pmax(pet.interp(month.seq), 0)
aet.seq <- pmin(pmax(aet.interp(month.seq), 0), pmax(pet.interp(month.seq), 0))
def.seq <- pmax(def.interp(month.seq), 0)
plot(0, 0, type='n', xlim=c(1, 12), ylim=c(y.range), ylab='Water (mm)', xlab='', las = 1, axes = FALSE)
p.1.x <- month.seq
p.1.y <- rep(0, length(month.seq))
p.2.x <- rev(p.1.x)
p.2.y <- pmax(ppt.interp(p.2.x), 0)
polygon(c(p.1.x, p.2.x), c(p.1.y, p.2.y), col=col.ppt, border=NA)
p.1.x <- month.seq
p.1.y <- rep(0, length(month.seq))
p.2.x <- rev(p.1.x)
p.2.y <- pmax(pet.interp(p.2.x), 0)
polygon(c(p.1.x, p.2.x), c(p.1.y, p.2.y), col=col.pet, border=NA)
p.1.x <- month.seq
p.1.y <- rep(0, length(month.seq))
p.2.x <- rev(p.1.x)
p.2.y <- pmin(pmax(aet.interp(p.2.x), 0), pmax(pet.interp(p.2.x), 0))
polygon(c(p.1.x, p.2.x), c(p.1.y, p.2.y), col = col.utilization, border = NA)
lines(ppt.seq ~ month.seq, type='l', lwd=2, lty = line.lty[1], col = line.col)
lines(pet.seq ~ month.seq, type='l', lwd=2, lty = line.lty[2], col = line.col)
lines(aet.seq ~ month.seq, type='l', lwd=2, lty = line.lty[3], col = line.col)
axis(side = 1, at = month.start:month.end, labels = WB$mo, line = 0, tick = TRUE, font = 2, cex = month.cex, col = NA, col.ticks = par('fg'))
axis(side = 2, at = pretty(y.range, n = 8), las = 1)
grid()
legend(x = 0, y = y.range[2], legend=c('Surplus / Recharge', 'Utilization', 'Deficit'), col=c(col.ppt, col.utilization, col.pet), pch=c(15, 15, 15), pt.cex=2, bty='n', horiz = TRUE, xpd = NA, xjust = 0, yjust = -0.25)
legend(x = 12, y = y.range[2], legend = c('PPT', 'PET', 'AET'), col = line.col, lwd = 2, lty = line.lty, bty='n', horiz = TRUE, xpd = NA, xjust = 1, yjust = -0.25)
AWC <- attr(WB, 'AWC')
mtext(sprintf("AWC: %s mm", AWC), side = 1, at = 1, cex = 0.85, adj = 0, line = 2.5)
sumD <- bquote(sum(Deficit) == .(round(sum(WB$D)))~mm)
mtext(sumD, side = 1, at = 12, cex = 0.85, adj = 1, line = 2.5)
}
|
bincont <- function (cov) {
ifelse(length(unique(cov)) == 2, "binary", "continuous")
}
weighted_sd <- function (cov, weights) {
weighted.mean <- sum(cov * weights) / sum(weights)
sqrt(1 / (sum(weights) - 1) * sum(weights * (cov - weighted.mean)^2))
}
plot_balance <- function (result, standardize = TRUE, absolute = TRUE, threshold = 0, sort = TRUE) {
if (standardize == TRUE) {
std <- "Standardized"
} else {
std <- "Unstandardized"
}
diff <- paste(std, "Mean Differences")
result$covariates <- factor(result$covariates, levels = result$covariates[nrow(result):1])
result$type <- ((result$type == "binary") * 3 + 21)
result <- result[nrow(result):1, ]
if (absolute == TRUE) {
result$diff.adj <- abs(result$diff.adj)
result$diff.un <- abs(result$diff.un)
diff <- paste("Absolute", std, "Mean Differences")
} else {
threshold <- c(-threshold, threshold)
}
if (sort == TRUE) {
order.un <- order(result$diff.un)
if (absolute == FALSE) {
order.un <- order(result$diff.un, decreasing = TRUE)
}
result$covariates <- factor(result$covariates, levels = result$covariates[order.un])
result <- result[order.un, ]
}
mindiff <- min(c(0, min(c(result$diff.un, result$diff.adj))))
maxdiff <- max(c(result$diff.un, result$diff.adj))
if (absolute == TRUE) {
legendx <- (maxdiff * 5 / 8)
} else {
legendx <- mindiff * 1.1
}
cols0 <- c(grDevices::rgb(0 / 255, 184 / 255, 148 / 255),
grDevices::rgb(225 / 255, 112 / 255, 85 / 255))
cols <- rep(cols0, each = 2)
pchs <- rep(c(21, 24), 2)
oldpar <- graphics::par(no.readonly = TRUE)
on.exit(graphics::par(oldpar), add = TRUE)
graphics::plot(x = result$diff.un,
y = result$covariates,
pch = result$type,
col = cols0[1],
cex = 1.7,
lwd = 2.2,
xlim = c(mindiff, maxdiff),
xlab = "", ylab = "",
axes = FALSE)
graphics::par(new = TRUE)
graphics::plot(x = result$diff.adj,
y = result$covariates,
pch = result$type,
col = cols0[2],
cex = 1.7,
lwd = 2.2,
xlim = c(mindiff, maxdiff),
xlab = diff, ylab = "",
yaxt = "n",
main = "Covariate balance")
graphics::abline(v = 0, col = "grey10", lty = "solid")
graphics::abline(v = threshold, col = "grey50", lty = "dashed", lwd = 1.2)
graphics::axis(2, at = c(1:nrow(result)), labels = result$covariates, las = 1)
graphics::par(xpd = TRUE)
if (sort == FALSE) {
legendx <- graphics::par()$usr[2]
}
graphics::legend(x = legendx, y = 1,
legend = c("Adjusted: continuous", "Adjusted: binary",
"Unadjusted: continuous", "Unadjusted: binary"),
col = cols[4:1], pch = pchs, pt.cex = 1.5, pt.lwd = 2, yjust = 0,
x.intersp = 0.7, y.intersp = 0.9,
bty = "n",
bg = "transparent")
}
|
index.H<-function(x,clall,d=NULL,centrotypes="centroids")
{
wgss<-function(x,cl,d,centroids)
{
n <- length(cl)
k <- max(cl)
if(is.null(dim(x))){
dim(x)<-c(length(x),1)
}
centers<-matrix(nrow=k,ncol=ncol(x))
for(i in 1:k){
if(centrotypes=="centroids"){
if(ncol(x)==1){
centers[i,]<-mean(x[cl==i,])
}
else{
if(is.null(dim(x[cl==i,]))){
centers[i,]<-x[cl==i]
}
else{
centers[i,]<-apply(x[cl==i,],2,mean)
}
}
}
else{
centers[i,]<-.medoid(x[cl==i,],d[cl==i,cl==i])
}
}
withins <- rep(0, k)
x <- (x - centers[cl,])^2
for(i in 1:k){
withins[i] <- sum(x[cl==i,])
}
sum(withins)
}
if(sum(c("centroids","medoids")==centrotypes)==0)
stop("Wrong centrotypes argument")
if("medoids"==centrotypes && is.null(d))
stop("For argument centrotypes = 'medoids' d cannot be null")
if(!is.null(d)){
if(!is.matrix(d)){
d<-as.matrix(d)
}
row.names(d)<-row.names(x)
}
if(is.null(dim(x))){
dim(x)<-c(length(x),1)
}
n <- nrow(x)
g <- max(clall[,1])
(wgss(x,clall[,1],d,centrotypes)/wgss(x,clall[,2],d,centrotypes)-1)*(n-g+1)
}
|
tNSS.JD <- function(x, K = 12, n.cuts = NULL, eps = 1e-06, maxiter = 100, ...)
{
dim_x <- dim(x)
r <- length(dim_x) - 1
n <- dim_x[r + 1]
if(length(dim_x) == 2){
Xmu <- rowMeans(x)
returnlist <- NSS.JD(t(x), K = K, n.cuts = n.cuts, eps = eps, maxiter = maxiter, ...)
returnlist$S <- t(returnlist$S)
returnlist2 <- list(S = returnlist$S,
W = returnlist$W,
K = returnlist$K,
n.cuts = returnlist$n.cut,
Xmu = Xmu,
datatype = "ts")
class(returnlist2) <- c("tbss", "bss")
return(returnlist2)
}
if(is.null(n.cuts))
{
if(K == 1)
{
slices <- rep(1, n)
n.cuts <- c(0, n)
} else {
slices <- as.numeric(cut(1:n, breaks = K, labels = 1:K))
n.cuts <- c(0, which(slices[-n] - slices[-1] == -1), n)
}
} else {
K <- length(n.cuts) - 1
slices <- as.numeric(cut(1:n, breaks = n.cuts, labels = 1:K))
}
xmu <- apply(x, 1:r, mean)
res_stand <- tensorStandardize(x)
x_stand <- res_stand$x
U_list <- vector("list", r)
for(m in 1:r)
{
current_dim <- dim_x[m]
matrix_array <- array(0, dim=c(current_dim, current_dim, K))
for(h in 1:K)
{
x_slice <- arraySelectLast(x_stand, (slices == h))
mMAC <- mModeCovariance(x_slice, m, center = TRUE)
matrix_array[, , h] <- 0.5*(mMAC + t(mMAC))
}
U_list[[m]] <- frjd(matrix_array, eps = eps, maxiter = maxiter, ...)$V
}
S <- x_stand
for(m in 1:r)
{
S <- tensorTransform(S, t(U_list[[m]]), m)
}
W <- vector("list", r)
for(m in 1:r)
{
W[[m]] <- crossprod(U_list[[m]], res_stand$S[[m]])
}
returnlist <- list(S = S,
W = W,
K = K,
n.cuts = n.cuts,
Xmu = xmu,
datatype = "ts")
class(returnlist) <- c("tbss", "bss")
return(returnlist)
}
|
createDSR <- function(areasAndDSRParam = NULL, spinning = 2, overwrite = FALSE, opts = antaresRead::simOptions() ){
oldOps <- opts
areasAndDSRParam <- .checkDataForAddDSR(areasAndDSRParam, spinning, overwrite, oldOps)
newOpts <- .addDSRArea(areasAndDSRParam, overwrite, opts = oldOps)
newOpts <- .addLinksBetweenDSRAndAreas(areasAndDSRParam = areasAndDSRParam, overwrite = overwrite, opts = newOpts)
newOpts <- .addBindingConstraintToDSR(areasAndDSRParam = areasAndDSRParam, overwrite = overwrite, opts = newOpts)
newOpts <- .AddClusterToDST(areasAndDSRParam = areasAndDSRParam, spinning = spinning, overwrite = overwrite, opts = newOpts)
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
.checkDataForAddDSR <- function(areasAndDSRParam = NULL, spinning = NULL, overwrite = NULL, opts = NULL){
if (!is.data.frame(areasAndDSRParam)){
stop("areasAndDSRParam must be a data.frame", call. = FALSE)
}
if (is.null(areasAndDSRParam$area) | is.null(areasAndDSRParam$unit) | is.null(areasAndDSRParam$nominalCapacity) | is.null(areasAndDSRParam$marginalCost) | is.null(areasAndDSRParam$hour)){
stop("areasAndDSRParam must be a data.frame with a column area, unit, nominalCapacity, marginalCost and hour", call. = FALSE)
}
for ( i in c("marginalCost", "hour", "unit")){
if (!is.numeric(areasAndDSRParam[i][1, ])){
stop(paste0(i, " is not numeric."), call. = FALSE)
}
}
sapply(areasAndDSRParam$area, function(x){
if (!(x %in% antaresRead::getAreas())){
stop(paste0(x, " is not a valid area."), call. = FALSE)
}
})
if (length(antaresRead::getAreas()) == 0 | identical(antaresRead::getAreas(), "")){
stop("There is no area in your study.", call. = FALSE)
}
if (is.null(spinning)){
stop("spinning is set to NULL", call. = FALSE)
}
if (!is.double(spinning)){
stop("spinning is not a double.", call. = FALSE)
}
return(areasAndDSRParam)
}
.getNameDsr <- function(area=NULL, hour=NULL){
nameDsr <- paste0(area, "_dsr_", hour, "h")
nameDsr
}
.addDSRArea <- function(areasAndDSRParam = NULL, overwrite = NULL, opts = NULL){
area <- NULL
y <- NULL
invisible(apply(areasAndDSRParam, 1, function(x){
areaName <- x["area"]
numberHour <- x["hour"]
nameDsr <- .getNameDsr(areaName, numberHour)
if (!(casefold(nameDsr, upper = FALSE) %in% antaresRead::getAreas()) | overwrite){
if (overwrite & (casefold(nameDsr, upper = FALSE) %in% antaresRead::getAreas())){
removeArea(name = nameDsr)
}
xyLayout <- antaresRead::readLayout()
LocX <- xyLayout$areas[area == areaName, x] - 20
LocY <- xyLayout$areas[area == areaName, y] - 20
createArea(nameDsr,
color = grDevices::rgb(150, 150, 150, max = 255),
localization = c(LocX, LocY),
overwrite = overwrite
)
}else{
warning(paste0(nameDsr,
" already exists, use argument overwrite if you want to edit this area.
All previous links will be lost."), call. = FALSE)
}
}))
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
.addLinksBetweenDSRAndAreas <- function(areasAndDSRParam = NULL, overwrite = NULL, opts = NULL){
invisible(apply(areasAndDSRParam, 1, function(x){
areaName <- x["area"]
numberHour <- x["hour"]
installedCapacityLink <- as.double(x["unit"]) * as.double(x["nominalCapacity"])
nameDsr <- .getNameDsr(areaName, numberHour)
conditionToCreateALink <- paste0(areaName, " - ", nameDsr) %in% antaresRead::getLinks() | paste0(nameDsr, " - ", areaName) %in% antaresRead::getLinks()
if (!conditionToCreateALink | overwrite){
if (is_antares_v7(opts)) {
dataLinkVirtual <- matrix(data = c(rep(0, 8760), rep(installedCapacityLink, 8760), rep(0, 8760*6)), ncol = 8)
} else {
dataLinkVirtual <- matrix(data = c(rep(0, 8760), rep(installedCapacityLink, 8760), rep(0, 8760*3)), ncol = 5)
}
dataLinkProperties <- propertiesLinkOptions()
dataLinkProperties$`hurdles-cost` <- FALSE
createLink(from = areaName, to = nameDsr, dataLink = dataLinkVirtual, propertiesLink = dataLinkProperties, opts = opts, overwrite = overwrite)
}else{
stop(paste0("The link ", areaName, " - ", nameDsr, " already exist, use overwrite."), call. = FALSE)
}
}))
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
.addBindingConstraintToDSR <- function(areasAndDSRParam = NULL, overwrite = NULL, opts = NULL){
invisible(apply(areasAndDSRParam, 1, function(x){
areaName <- x["area"]
numberHour <- x["hour"]
installedCapacityLink <- as.double(x["unit"]) * as.double(x["nominalCapacity"])
nameDsr <- .getNameDsr(areaName, numberHour)
nameBindDSR <- nameDsr
coefficientsDSR <- .getCoefDsr(areaName, nameDsr)
createBindingConstraint(nameBindDSR, values = matrix(data = c(rep(installedCapacityLink * as.double(numberHour), 365), rep(0, 365 * 2)), ncol = 3),
enabled = TRUE, timeStep = "daily",
operator = c("less"), coefficients = coefficientsDSR,
overwrite = overwrite)
}))
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
.getCoefDsr <- function(areaName = NULL, dsrName = NULL){
if (areaName < dsrName){
nameCoefDSR <- tolower(paste0(areaName, "%", dsrName))
coeffDsr <- (-1)
}else {
nameCoefDSR <- tolower(paste0(dsrName, "%", areaName))
coeffDsr <- (1)
}
coefficientsDSR <- c( coeffDsr )
names(coefficientsDSR)[1] <- nameCoefDSR
return(coefficientsDSR)
}
.AddClusterToDST <- function(areasAndDSRParam = NULL, spinning = NULL, overwrite = NULL, opts = NULL){
invisible(apply(areasAndDSRParam, 1, function(x){
areaName <- x["area"]
numberHour <- x["hour"]
unitDSR <- x["unit"]
marginalCost <- x["marginalCost"]
nominalCapacity <- x["nominalCapacity"]
nameDsr <- .getNameDsr(areaName, numberHour)
createCluster(nameDsr,
cluster_name = paste0(nameDsr, "_cluster"),
group = "Other",
unitcount = as.integer(unitDSR),
`marginal-cost` = marginalCost,
enabled = TRUE,
spinning = spinning,
nominalcapacity = nominalCapacity,
overwrite = overwrite,
add_prefix = FALSE)
}))
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
getCapacityDSR <- function(area = NULL, opts = antaresRead::simOptions()){
check_area_name(area, opts = opts)
nameDsr <- .getTheDsrName(area)
clusterList <- antaresRead::readClusterDesc(opts = opts)
unit <- as.double(clusterList[area == nameDsr]$unitcount)
nominalcapacity <- as.double(clusterList[area == nameDsr]$nominalcapacity)
return(unit * nominalcapacity)
}
.getTheDsrName <- function(area = NULL){
if (TRUE %in% grepl(paste0(area, "_dsr"), antaresRead::getAreas() )){
nameDsr <- grep(paste0(area, "_dsr"), antaresRead::getAreas(), value = TRUE )
}else {
stop("There is no DSR for this area")
}
return(nameDsr)
}
editDSR <- function(area = NULL, unit = NULL, nominalCapacity = NULL, marginalCost = NULL, spinning = NULL, opts = antaresRead::simOptions()){
check_area_name(area, opts = opts)
.checkDataEditDSR(area, unit, nominalCapacity, marginalCost, spinning)
bindingList <- antaresRead::readBindingConstraints(opts = opts)
clusterList <- antaresRead::readClusterDesc(opts = opts)
previousNameDsr <- .getTheDsrName(area)
previousUnitCount <- as.double(clusterList[area == previousNameDsr]$unitcount)
previousNominalCapacity <- as.double(clusterList[area == previousNameDsr]$nominalcapacity)
capaBinding <- unique(bindingList[previousNameDsr][[1]]$values$less[1])
previousNumberHour <- round(as.double(capaBinding / (previousNominalCapacity * previousUnitCount)))
if (is.null(unit) & is.null(nominalCapacity)){
newCapacityLink <- previousUnitCount * previousNominalCapacity
} else{
newCapacityLink <- unit * nominalCapacity
}
createCluster(previousNameDsr,
cluster_name = paste0(previousNameDsr, "_cluster"),
group = "Other",
unitcount = as.integer(unit),
`marginal-cost` = marginalCost,
enabled = TRUE,
spinning = spinning,
nominalcapacity = nominalCapacity,
overwrite = TRUE,
add_prefix = FALSE,
opts = opts)
coefficientsDSR <- .getCoefDsr(area, previousNameDsr)
createBindingConstraint(previousNameDsr, values = matrix(data = c(rep(newCapacityLink * as.double(previousNumberHour), 365), rep(0, 365 * 2)), ncol = 3),
enabled = TRUE, timeStep = "daily",
operator = c("less"), coefficients = coefficientsDSR,
overwrite = TRUE, opts = opts)
if (is_antares_v7(opts)) {
dataLinkVirtual <- matrix(data = c(rep(0, 8760), rep(newCapacityLink, 8760), rep(0, 8760*6)), ncol = 8)
} else {
dataLinkVirtual <- matrix(data = c(rep(0, 8760), rep(newCapacityLink, 8760), rep(0, 8760*3)), ncol = 5)
}
dataLinkProperties <- propertiesLinkOptions()
dataLinkProperties$`hurdles-cost` <- FALSE
createLink(from = area,
to = previousNameDsr,
dataLink = dataLinkVirtual,
propertiesLink = dataLinkProperties,
opts = opts,
overwrite = TRUE)
suppressWarnings({
res <- antaresRead::setSimulationPath(path = opts$studyPath, simulation = "input")
})
invisible(res)
}
.checkDataEditDSR <- function(area = NULL, unit = NULL, nominalCapacity = NULL, marginalCost = NULL, spinning = NULL){
for ( i in c(unit, nominalCapacity, marginalCost, spinning)){
if (!is.numeric(i)){
stop(paste0(i, " is not numeric."), call. = FALSE)
}
}
if ( (is.null(unit) & !is.null(nominalCapacity)) | (!is.null(unit) & is.null(nominalCapacity))){
stop(paste0("unit or nominalCapacity is set to NULL"), call. = FALSE)
}
}
|
computeSigmaHat <- function(lavmodel = NULL, GLIST = NULL, extra = FALSE,
delta = TRUE, debug = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nmat <- lavmodel@nmat
nvar <- lavmodel@nvar
nblocks <- lavmodel@nblocks
representation <- lavmodel@representation
Sigma.hat <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[mm.in.group]
if(representation == "LISREL") {
Sigma.hat[[g]] <- computeSigmaHat.LISREL(MLIST = MLIST,
delta = delta)
} else if(representation == "RAM") {
Sigma.hat[[g]] <- lav_ram_sigmahat(MLIST = MLIST, delta = delta)
} else {
stop("only LISREL and RAM representation has been implemented for now")
}
if(debug) print(Sigma.hat[[g]])
if(extra) {
ev <- eigen(Sigma.hat[[g]], symmetric=TRUE, only.values=TRUE)$values
if(any(ev < sqrt(.Machine$double.eps)) || sum(ev) == 0) {
Sigma.hat.inv <- MASS::ginv(Sigma.hat[[g]])
Sigma.hat.log.det <- log(.Machine$double.eps)
attr(Sigma.hat[[g]], "po") <- FALSE
attr(Sigma.hat[[g]], "inv") <- Sigma.hat.inv
attr(Sigma.hat[[g]], "log.det") <- Sigma.hat.log.det
} else {
Sigma.hat.inv <- inv.chol(Sigma.hat[[g]], logdet = TRUE)
Sigma.hat.log.det <- attr(Sigma.hat.inv, "logdet")
attr(Sigma.hat[[g]], "po") <- TRUE
attr(Sigma.hat[[g]], "inv") <- Sigma.hat.inv
attr(Sigma.hat[[g]], "log.det") <- Sigma.hat.log.det
}
}
}
Sigma.hat
}
computeSigmaHatJoint <- function(lavmodel = NULL, GLIST = NULL, extra = FALSE,
delta = TRUE, debug = FALSE) {
stopifnot([email protected])
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nmat <- lavmodel@nmat
nvar <- lavmodel@nvar
nblocks <- lavmodel@nblocks
representation <- lavmodel@representation
Sigma.hat <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[mm.in.group]
if(representation == "LISREL") {
res.Sigma <- computeSigmaHat.LISREL(MLIST = MLIST, delta = delta)
res.int <- computeMuHat.LISREL(MLIST = MLIST)
res.slopes <- computePI.LISREL(MLIST = MLIST)
S.xx <- MLIST$cov.x
S.yy <- res.Sigma + res.slopes %*% S.xx %*% t(res.slopes)
S.yx <- res.slopes %*% S.xx
S.xy <- S.xx %*% t(res.slopes)
Sigma.hat[[g]] <- rbind( cbind(S.yy, S.yx), cbind(S.xy, S.xx) )
} else {
stop("only representation LISREL has been implemented for now")
}
if(debug) print(Sigma.hat[[g]])
if(extra) {
ev <- eigen(Sigma.hat[[g]], symmetric=TRUE, only.values=TRUE)$values
if(any(ev < .Machine$double.eps) || sum(ev) == 0) {
Sigma.hat.inv <- MASS::ginv(Sigma.hat[[g]])
Sigma.hat.log.det <- log(.Machine$double.eps)
attr(Sigma.hat[[g]], "po") <- FALSE
attr(Sigma.hat[[g]], "inv") <- Sigma.hat.inv
attr(Sigma.hat[[g]], "log.det") <- Sigma.hat.log.det
} else {
Sigma.hat.inv <- inv.chol(Sigma.hat[[g]], logdet=TRUE)
Sigma.hat.log.det <- attr(Sigma.hat.inv, "logdet")
attr(Sigma.hat[[g]], "po") <- TRUE
attr(Sigma.hat[[g]], "inv") <- Sigma.hat.inv
attr(Sigma.hat[[g]], "log.det") <- Sigma.hat.log.det
}
}
}
Sigma.hat
}
computeMuHat <- function(lavmodel = NULL, GLIST = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nmat <- lavmodel@nmat
nblocks <- lavmodel@nblocks
representation <- lavmodel@representation
meanstructure <- lavmodel@meanstructure
Mu.hat <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[mm.in.group]
if(!meanstructure) {
Mu.hat[[g]] <- numeric( lavmodel@nvar[g] )
} else
if(representation == "LISREL") {
Mu.hat[[g]] <- computeMuHat.LISREL(MLIST = MLIST)
} else if(representation == "RAM") {
Mu.hat[[g]] <- lav_ram_muhat(MLIST = MLIST)
} else {
stop("only RAM and LISREL representation has been implemented for now")
}
}
Mu.hat
}
computeMuHatJoint <- function(lavmodel = NULL, GLIST = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nmat <- lavmodel@nmat
nblocks <- lavmodel@nblocks
representation <- lavmodel@representation
meanstructure <- lavmodel@meanstructure
Mu.hat <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
if(!meanstructure) {
Mu.hat[[g]] <- numeric( lavmodel@nvar[g] )
} else if(representation == "LISREL") {
MLIST <- GLIST[ mm.in.group ]
res.int <- computeMuHat.LISREL(MLIST = MLIST)
res.slopes <- computePI.LISREL(MLIST = MLIST)
M.x <- MLIST$mean.x
Mu.y <- res.int + res.slopes %*% M.x
Mu.x <- M.x
Mu.hat[[g]] <- c(Mu.y, Mu.x)
} else {
stop("only representation LISREL has been implemented for now")
}
}
Mu.hat
}
computeTH <- function(lavmodel = NULL, GLIST = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
th.idx <- [email protected]
TH <- vector("list", length=nblocks)
for(g in 1:nblocks) {
if(length(th.idx[[g]]) == 0) {
TH[[g]] <- numeric(0L)
next
}
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
if(representation == "LISREL") {
TH[[g]] <- computeTH.LISREL(MLIST = GLIST[ mm.in.group ],
th.idx=th.idx[[g]])
} else {
stop("only representation LISREL has been implemented for now")
}
}
TH
}
computePI <- function(lavmodel = NULL, GLIST = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
conditional.x <- [email protected]
PI <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(!conditional.x) {
PI.g <- numeric( lavmodel@nvar[g] )
} else
if(representation == "LISREL") {
PI.g <- computePI.LISREL(MLIST = MLIST)
} else {
stop("only representation LISREL has been implemented for now")
}
PI[[g]] <- PI.g
}
PI
}
computeGW <- function(lavmodel = NULL, GLIST=NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
group.w.free <- [email protected]
GW <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(!group.w.free) {
GW.g <- 0.0
} else
if(representation == "LISREL") {
GW.g <- as.numeric(MLIST$gw[1,1])
} else {
stop("only representation LISREL has been implemented for now")
}
GW[[g]] <- GW.g
}
GW
}
computeVY <- function(lavmodel = NULL, GLIST = NULL, diagonal.only = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
VY <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
VY.g <- computeVY.LISREL(MLIST = MLIST)
} else {
stop("only representation LISREL has been implemented for now")
}
if(diagonal.only) {
VY[[g]] <- diag(VY.g)
} else {
VY[[g]] <- VY.g
}
}
VY
}
computeVETA <- function(lavmodel = NULL, GLIST = NULL,
remove.dummy.lv = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
VETA <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
VETA.g <- computeVETA.LISREL(MLIST = MLIST)
if(remove.dummy.lv) {
lv.idx <- c([email protected][[g]],
[email protected][[g]])
if(!is.null(lv.idx)) {
VETA.g <- VETA.g[-lv.idx, -lv.idx, drop=FALSE]
}
}
} else if(representation == "RAM") {
VETA.g <- lav_ram_veta(MLIST = MLIST)
} else {
stop("only LISREL and RAM representation has been implemented for now")
}
VETA[[g]] <- VETA.g
}
VETA
}
computeVETAx <- function(lavmodel = NULL, GLIST = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
ETA <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
lv.idx <- c([email protected][[g]],
[email protected][[g]])
ETA.g <- computeVETAx.LISREL(MLIST = MLIST,
lv.dummy.idx = lv.idx)
} else {
stop("only representation LISREL has been implemented for now")
}
ETA[[g]] <- ETA.g
}
ETA
}
computeCOV <- function(lavmodel = NULL, GLIST = NULL,
remove.dummy.lv = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
COV <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
COV.g <- computeCOV.LISREL(MLIST = MLIST)
if(remove.dummy.lv) {
lv.idx <- c([email protected][[g]],
[email protected][[g]])
if(!is.null(lv.idx)) {
lambda.names <-
lavmodel@dimNames[[which(names(GLIST) == "lambda")[g]]][[1L]]
lv.idx <- lv.idx + length(lambda.names)
COV.g <- COV.g[-lv.idx, -lv.idx, drop=FALSE]
}
}
} else {
stop("only representation LISREL has been implemented for now")
}
COV[[g]] <- COV.g
}
COV
}
computeEETA <- function(lavmodel = NULL, GLIST = NULL, lavsamplestats = NULL,
remove.dummy.lv = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
EETA <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
EETA.g <- computeEETA.LISREL(MLIST,
[email protected][[g]],
sample.mean=lavsamplestats@mean[[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]])
if(remove.dummy.lv) {
lv.dummy.idx <- c([email protected][[g]],
[email protected][[g]])
if(length(lv.dummy.idx) > 0L) {
EETA.g <- EETA.g[-lv.dummy.idx]
}
}
} else {
stop("only representation LISREL has been implemented for now")
}
EETA[[g]] <- EETA.g
}
EETA
}
computeEETAx <- function(lavmodel = NULL, GLIST = NULL, lavsamplestats = NULL,
eXo = NULL, nobs = NULL, remove.dummy.lv = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
EETAx <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
EXO <- eXo[[g]]
if(is.null(EXO)) {
EXO <- matrix(0, nobs[[g]], 0L)
}
if(representation == "LISREL") {
EETAx.g <- computeEETAx.LISREL(MLIST,
eXo=EXO, N=nobs[[g]],
sample.mean=lavsamplestats@mean[[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]])
if(remove.dummy.lv) {
lv.dummy.idx <- c([email protected][[g]],
[email protected][[g]])
if(length(lv.dummy.idx) > 0L) {
EETAx.g <- EETAx.g[ ,-lv.dummy.idx, drop=FALSE]
}
}
} else {
stop("only representation LISREL has been implemented for now")
}
EETAx[[g]] <- EETAx.g
}
EETAx
}
computeLAMBDA <- function(lavmodel = NULL, GLIST = NULL,
handle.dummy.lv = TRUE,
remove.dummy.lv = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
LAMBDA <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
if(handle.dummy.lv) {
ov.y.dummy.ov.idx = [email protected][[g]]
ov.x.dummy.ov.idx = [email protected][[g]]
ov.y.dummy.lv.idx = [email protected][[g]]
ov.x.dummy.lv.idx = [email protected][[g]]
} else {
ov.y.dummy.ov.idx = NULL
ov.x.dummy.ov.idx = NULL
ov.y.dummy.lv.idx = NULL
ov.x.dummy.lv.idx = NULL
}
LAMBDA.g <- computeLAMBDA.LISREL(MLIST = MLIST,
ov.y.dummy.ov.idx = ov.y.dummy.ov.idx,
ov.x.dummy.ov.idx = ov.x.dummy.ov.idx,
ov.y.dummy.lv.idx = ov.y.dummy.lv.idx,
ov.x.dummy.lv.idx = ov.x.dummy.lv.idx,
remove.dummy.lv = remove.dummy.lv)
} else {
stop("only representation LISREL has been implemented for now")
}
LAMBDA[[g]] <- LAMBDA.g
}
LAMBDA
}
computeTHETA <- function(lavmodel = NULL, GLIST = NULL, fix = TRUE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
THETA <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
if(fix) {
THETA.g <- computeTHETA.LISREL(MLIST = MLIST,
ov.y.dummy.ov.idx = [email protected][[g]],
ov.x.dummy.ov.idx = [email protected][[g]],
ov.y.dummy.lv.idx = [email protected][[g]],
ov.x.dummy.lv.idx = [email protected][[g]])
} else {
THETA.g <- computeTHETA.LISREL(MLIST = MLIST)
}
} else if(representation == "RAM") {
ov.idx <- as.integer(MLIST$ov.idx[1,])
THETA.g <- MLIST$S[ov.idx, ov.idx, drop = FALSE]
} else {
stop("only LISREL and RAM representation has been implemented for now")
}
THETA[[g]] <- THETA.g
}
THETA
}
computeNU <- function(lavmodel = NULL, GLIST = NULL,
lavsamplestats = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
NU <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
NU.g <- computeNU.LISREL(MLIST = MLIST,
sample.mean = lavsamplestats@mean[[g]],
ov.y.dummy.ov.idx = [email protected][[g]],
ov.x.dummy.ov.idx = [email protected][[g]],
ov.y.dummy.lv.idx = [email protected][[g]],
ov.x.dummy.lv.idx = [email protected][[g]])
} else {
stop("only representation LISREL has been implemented for now")
}
NU[[g]] <- NU.g
}
NU
}
computeEY <- function(lavmodel = NULL, GLIST = NULL, lavsamplestats = NULL) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
nblocks <- lavmodel@nblocks
nmat <- lavmodel@nmat
representation <- lavmodel@representation
EY <- vector("list", length=nblocks)
for(g in 1:nblocks) {
mm.in.group <- 1:nmat[g] + cumsum(c(0,nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(representation == "LISREL") {
EY.g <- computeEY.LISREL(MLIST = MLIST,
[email protected][[g]],
sample.mean=lavsamplestats@mean[[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]],
[email protected][[g]])
} else {
stop("only representation LISREL has been implemented for now")
}
EY[[g]] <- EY.g
}
EY
}
computeYHAT <- function(lavmodel = NULL, GLIST = NULL, lavsamplestats = NULL,
eXo = NULL, nobs = NULL, ETA = NULL, duplicate = FALSE) {
if(is.null(GLIST)) GLIST <- lavmodel@GLIST
ngroups <- lavsamplestats@ngroups
YHAT <- vector("list", length=ngroups)
for(g in seq_len(ngroups)) {
mm.in.group <- 1:lavmodel@nmat[g] + cumsum(c(0L,lavmodel@nmat))[g]
MLIST <- GLIST[ mm.in.group ]
if(is.null(eXo[[g]]) && duplicate) {
Nobs <- nobs[[g]]
} else {
Nobs <- 1L
}
if(lavmodel@representation == "LISREL") {
if([email protected]) {
YHAT[[g]] <- computeEYetax.LISREL(MLIST = MLIST,
eXo = eXo[[g]], ETA = ETA[[g]], N = Nobs,
sample.mean = lavsamplestats@mean[[g]],
ov.y.dummy.ov.idx = [email protected][[g]],
ov.x.dummy.ov.idx = [email protected][[g]],
ov.y.dummy.lv.idx = [email protected][[g]],
ov.x.dummy.lv.idx = [email protected][[g]])
} else {
YHAT[[g]] <- computeEYetax3.LISREL(MLIST = MLIST,
ETA = ETA[[g]],
sample.mean = lavsamplestats@mean[[g]],
mean.x = [email protected][[g]],
ov.y.dummy.ov.idx = [email protected][[g]],
ov.x.dummy.ov.idx = [email protected][[g]],
ov.y.dummy.lv.idx = [email protected][[g]],
ov.x.dummy.lv.idx = [email protected][[g]])
}
} else {
stop("lavaan ERROR: representation ", lavmodel@representation,
" not supported yet.")
}
}
YHAT
}
|
block.check <- function (k, blocks, nfactors, factor.names=Letters[1:nfactors])
{
if (is.list(blocks)){
if (any(sapply(blocks, function(obj) any(obj < 1 | obj > nfactors |
!floor(obj) == obj))))
stop(paste("All block generators must contain integer numbers from 1 to",
nfactors, "\n or letters from", Letters[1], "to", Letters[nfactors],
"only."))}
else {
if (is.numeric(blocks) & length(blocks)==1) {
if (!(2^round(log2(blocks)))==blocks)
stop ("The number of blocks must be an integer power of 2.")
return(blocks)
}
if (!(is.numeric(blocks) | is.character(blocks)))
stop("blocks must be the number of blocks, a list of generator vectors, a character vector of block generators,
a numeric vector of column numbers of the Yates matrix, or
a character vector of factor names.")
if (is.numeric(blocks)) {
if (any(!blocks == floor(blocks)))
stop("All entries in blocks must be integer numbers.")
if (min(blocks) < 1 | max(blocks) > 2^k - 1)
stop("Column numbers in blocks must be in the range of 1 to 2^k-1.")
blocks <- Yates[blocks]
}
if (is.character(blocks)) {
hilf <- factor.names
if (is.list(hilf)) hilf <- names(hilf)
if (all(blocks %in% hilf)) blocks <- as.list(which(hilf %in% blocks))
else
blocks <- lapply(strsplit(blocks, ""), function(obj) which(Letters %in%
obj))
}
}
blocks
}
blockfull <- function(block.gen, k, des.gen=NULL){
if (is.list(block.gen) && is.null(des.gen))
stop("for list-valued block.gen, ",
"des.gen is needed (vector of Yates column numbers)")
k.block <- length(block.gen)
if (is.character(block.gen))
block.gen <- sapply(block.gen, function(obj) which(names(Yates) == obj))
if (is.list(block.gen))
block.gen <- sapply(block.gen, function(obj)
as.intBase(paste(rowSums(do.call(cbind,
lapply(obj, function(obj2)
digitsBase(des.gen[obj2],2,k))))%%2, collapse="")))
aus <- block.gen
if (k.block > 1)
for (i in 2:k.block){
sel <- DoE.base:::nchoosek(k.block, i)
aus <- c(aus,
sapply(1:ncol(sel),
function(obj)
as.intBase(
paste(
rowSums(
do.call(cbind,
lapply(sel[,obj], function(obj2)
digitsBase(block.gen[obj2],2,k)
))
)%%2,
collapse="")
)
))
}
aus
}
|
resid_fit <- function(S = NULL, Sigma = NULL, ybar = NULL, mu = NULL,
lavaan_object = NULL, exo = TRUE) {
if (!is.null(lavaan_object)) {
moment_list <- get_moments(lavaan_object, exo)
S <- moment_list[["S"]]
Sigma <- moment_list[["Sigma"]]
ybar <- moment_list[["ybar"]]
mu <- moment_list[["mu"]]
}
if (nrow(Sigma) != ncol(Sigma)) stop("Sigma is not a square matrix")
if (nrow(S) != ncol(S)) stop("S is not a square matrix")
if (sum(dim(S)) != sum(dim(Sigma))) stop("S and Sigma are not the same size")
if (!is.null(ybar) & !is.null(mu)) {
if (length(ybar) != length(mu)) stop("ybar and mu are not the same size")
if (length(ybar) != nrow(S)) stop("ybar/mu are not of the same dimension")
if (length(mu) != nrow(Sigma)) stop("S/Sigma are not of the same dimension")
}
D <- diag(sqrt(diag(S)))
invD <- solve(D)
if (is.null(ybar)) {
P_mean <- NULL
raw_dev_mean <- std_dev_mean <- dev_std_mean <- NULL
ss_raw_dev_mean <- ss_std_dev_mean <- ss_dev_std_mean <- NULL
rmr_mean <- srmr_mean <- crmr_mean <- NULL
} else {
P_mean <- length(ybar)
raw_dev_mean <- ybar - mu
ss_raw_dev_mean <- sum(raw_dev_mean^2)
rmr_mean <- resid_index(ssr = ss_raw_dev_mean, P = P_mean)
std_dev_mean <- invD %*% raw_dev_mean
ss_std_dev_mean <- sum(std_dev_mean^2)
srmr_mean <- resid_index(ssr = ss_std_dev_mean, P = P_mean)
std_samp_mean <- ybar / sqrt(diag(S))
std_impld_mean <- mu / sqrt(diag(Sigma))
dev_std_mean <- std_samp_mean - std_impld_mean
ss_dev_std_mean <- sum(dev_std_mean^2)
crmr_mean <- resid_index(ssr = ss_dev_std_mean, P = P_mean)
}
P_lt <- (nrow(S) * (nrow(S) - 1)) / 2
raw_dev_vcov <- S - Sigma
ss_raw_dev_lt <- sum_sq_lt(raw_dev_vcov)
rmr_cov <- resid_index(ssr = ss_raw_dev_lt, P = P_lt)
std_dev_vcov <- invD %*% raw_dev_vcov %*% invD
ss_std_dev_lt <- sum_sq_lt(std_dev_vcov)
srmr_cov <- resid_index(ssr = ss_std_dev_lt, P = P_lt)
Rho <- stats::cov2cor(Sigma)
R <- stats::cov2cor(S)
dev_std_vcov <- R - Rho
ss_dev_std_lt <- sum_sq_lt(dev_std_vcov)
crmr_cov <- resid_index(ssr = ss_dev_std_lt, P = P_lt)
if(all(diag(S) == diag(Sigma))) {
P_var <- NULL
} else {
P_var <- nrow(S)
ss_raw_dev_var <- sum(diag(raw_dev_vcov)^2)
rmr_var <- resid_index(ssr = ss_raw_dev_var, P = P_var)
ss_std_dev_var <- sum(diag(std_dev_vcov)^2)
srmr_var <- resid_index(ssr = ss_std_dev_var, P = P_var)
}
P <- sum(P_mean, P_var, P_lt)
ss_raw_dev_total <- sum(ss_raw_dev_lt, ss_raw_dev_var, ss_raw_dev_mean)
rmr_total <- resid_index(ssr = ss_raw_dev_total, P = P)
ss_std_dev_total <- sum(ss_std_dev_lt, ss_std_dev_var, ss_std_dev_mean)
srmr_total <- resid_index(ssr = ss_std_dev_total, P = P)
ss_dev_std_total <- sum(ss_dev_std_lt, ss_dev_std_mean)
crmr_total <- resid_index(ssr = ss_dev_std_total, P = sum(c(P_mean, P_lt)))
rmr_obj <- methods::new("ResidualFitIndex")
rmr_obj@type <- "RMR"
rmr_obj@resid <- list(mean = raw_dev_mean, vcov = raw_dev_vcov)
rmr_obj@ssr <- list(total = ss_raw_dev_total, mean = ss_raw_dev_mean,
var = ss_raw_dev_var, cov = ss_raw_dev_lt)
rmr_obj@size <- list(total = P, mean = P_mean, var = P_var, cov = P_lt)
rmr_obj@index <- list(total = rmr_total, mean = rmr_mean, var = rmr_var, cov = rmr_cov)
srmr_obj <- methods::new("ResidualFitIndex")
srmr_obj@type <- "SRMR"
srmr_obj@resid <- list(mean = std_dev_mean, vcov = std_dev_vcov)
srmr_obj@ssr <- list(total = ss_std_dev_total, mean = ss_std_dev_mean,
var = ss_std_dev_var, cov = ss_std_dev_lt)
srmr_obj@size <- list(total = P, mean = P_mean, var = P_var, cov = P_lt)
srmr_obj@index <- list(total = srmr_total, mean = srmr_mean, var = srmr_var,
cov = srmr_cov)
crmr_obj <- methods::new("ResidualFitIndex")
crmr_obj@type <- "CRMR"
crmr_obj@resid <- list(mean = dev_std_mean, vcov = dev_std_vcov)
crmr_obj@ssr <- list(total = ss_dev_std_total, mean = ss_dev_std_mean,
cov = ss_dev_std_lt)
crmr_obj@size <- list(total = P, mean = P_mean, cov = P_lt)
crmr_obj@index <- list(total = crmr_total, mean = crmr_mean, cov = crmr_cov)
resid_fit_obj <- methods::new("ResidualFitIndices")
resid_fit_obj@sampleMoments <- list(yBar = ybar, S = S, dim = length(ybar))
resid_fit_obj@impliedMoments <- list(muHat = mu, SigmaHat = Sigma, dim = length(mu))
resid_fit_obj@RMR = rmr_obj
resid_fit_obj@SRMR = srmr_obj
resid_fit_obj@CRMR = crmr_obj
return(resid_fit_obj)
}
|
HitMiss_Curve = function(ddF, miss_ind, p){
ddF_temp = ddF %>%
mutate(miss = miss_ind) %>%
mutate(hit = ifelse(miss_ind == TRUE, FALSE, TRUE)) %>%
select(AE_NAME, OR, hit, miss) %>%
distinct()
position = sapply(unique(ddF_temp$OR),
function(x) tail(which(ddF_temp$OR == x), n = 1),
simplify = T)
n_pos = length(position)
N_R = ddF_temp %>%
filter(hit == TRUE) %>%
mutate(OR_p = abs(OR)^p) %>%
summarize(Nr = sum(OR_p)) %>%
as.numeric()
N_miss = ddF_temp %>%
summarize(N_M = sum(miss_ind)) %>%
as.numeric()
if (N_R == 0){
hit_value = rep(0, n_pos)
}else{
if(p == 0){
hit_value = cumsum(ddF_temp$hit / N_R)
hit_value = hit_value[position]
} else{
OR_hit = ddF_temp %>%
mutate(OR_p = abs(OR)^p * hit)
hit_value = cumsum(OR_hit$OR_p / N_R)
hit_value = hit_value[position]
} }
miss_value = cumsum(ddF_temp$miss / N_miss)
miss_value = miss_value[position]
return(list(hit = hit_value, miss = miss_value, pos = position))
}
|
context("Test Graphics")
library(mpcmp)
data("attendance")
M.attendance <- glm.cmp(daysabs~ gender+math+prog,
data=attendance)
test_that("Test gg_plot",
{
expect_length(gg_plot(M.attendance, which = 1:8), 8)
expect_output(gg_plot(M.attendance, which=9),
NULL)
})
|
context("Network extended models")
test_that("edges models", {
skip_on_cran()
nw <- network_initialize(n = 100)
est <- netest(nw, formation = ~edges, target.stats = 25,
coef.diss = dissolution_coefs(~offset(edges), 10, 0),
verbose = FALSE)
expect_is(est, "netest")
param <- param.net(inf.prob = 0.5)
init <- init.net(i.num = 1)
control <- control.net(type = "SI", nsims = 1, nsteps = 25, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0)
init <- init.net(i.num = 1)
control <- control.net(type = "SI", nsims = 1, nsteps = 25, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) == 1)
expect_true(max(x$epi$si.flow, na.rm = TRUE) == 0)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5)
init <- init.net(i.num = 1)
control <- control.net(type = "SI", nsims = 2, nsteps = 25, verbose = FALSE,
nwstats.formula = ~edges + meandeg + concurrent)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "formation", plots.joined = FALSE)
plot(x, type = "formation", stats = "edges")
plot(x, type = "formation", stats = c("edges", "meandeg"))
plot(x, type = "formation", sim.lines = TRUE, qnts.smooth = FALSE)
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 1)
init <- init.net(i.num = 1)
control <- control.net(type = "SI", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_true(sum(get.vertex.attribute.active(x$network[[1]][[1]],
prefix = "testatus",
at = 1) == "i") >= 0)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5)
init <- init.net(status.vector = c(rep("i", 10),
rep("s", 90)))
control <- control.net(type = "SI", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(all(x$epi$i.num[1, ] == 10))
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.01)
init <- init.net(i.num = 10, r.num = 0)
control <- control.net(type = "SIR", nsims = 1, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0, rec.rate = 0.01)
init <- init.net(i.num = 10, r.num = 0)
control <- control.net(type = "SIR", nsims = 1,
nsteps = 25, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) == 10)
expect_true(max(x$epi$si.flow, na.rm = TRUE) == 0)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.1)
init <- init.net(i.num = 1, r.num = 0)
control <- control.net(type = "SIR", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.1)
init <- init.net(status.vector = rep(c("s", "i"), each = 50))
control <- control.net(type = "SIR", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(all(x$epi$i.num[1, ] == 50))
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.9, rec.rate = 0.01)
init <- init.net(i.num = 1)
control <- control.net(type = "SIS", nsims = 1, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0, rec.rate = 0.01)
init <- init.net(i.num = 1)
control <- control.net(type = "SIS", nsims = 1, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) == 1)
expect_true(max(x$epi$si.flow, na.rm = TRUE) == 0)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.01)
init <- init.net(i.num = 1)
control <- control.net(type = "SIS", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) >= 1)
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 1, rec.rate = 0.01)
init <- init.net(i.num = 1)
control <- control.net(type = "SIS", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(max(x$epi$i.num) <= 100)
expect_true(sum(get.vertex.attribute.active(x$network[[1]][[1]],
prefix = "testatus",
at = 1) == "i") >= 0)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.01)
init <- init.net(status.vector = c(rep("i", 10), rep("s", 90)))
control <- control.net(type = "SIS", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_true(all(x$epi$i.num[1, ] == 10))
expect_true(max(x$epi$i.num) <= 100)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", sims = "mean", col.status = TRUE)
test_net(x)
})
test_that("High departure rate models", {
skip_on_cran()
nw <- network_initialize(n = 25)
est <- netest(nw, formation = ~edges, target.stats = 12,
coef.diss = dissolution_coefs(~offset(edges), 10, 0.01),
edapprox = TRUE, verbose = FALSE)
param <- param.net(inf.prob = 0.5, act.rate = 2,
a.rate = 0.01, ds.rate = 0.25,
di.rate = 0.1)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 25, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_equal(unique(sapply(x$epi, nrow)), 25)
summary(x, at = 25)
expect_output(summary(x, at = 25), "EpiModel Summary")
get_nwstats(x)
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.1, act.rate = 2, a.rate = 0.01,
ds.rate = 0.01, di.rate = 0.25)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 25, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_equal(unique(sapply(x$epi, nrow)), 25)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
})
test_that("erroneous two-group models", {
nw <- network_initialize(n = 100)
nw <- set_vertex_attribute(nw, "group", rep(0:1, each = 50))
est <- netest(nw, formation = ~edges, target.stats = 25,
coef.diss = dissolution_coefs(~offset(edges), 10, 0),
edapprox = TRUE, verbose = FALSE)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1)
init <- init.net(i.num = 10, i.num.g2 = 0)
control <- control.net(type = "SI", nsims = 2, nsteps = 25, verbose = FALSE)
expect_error(netsim(est, param, init, control))
})
test_that("edges two-group models", {
skip_on_cran()
nw <- network_initialize(n = 100)
nw <- set_vertex_attribute(nw, "group", rep(1:2, each = 50))
est5 <- netest(nw, formation = ~edges, target.stats = 25,
coef.diss = dissolution_coefs(~offset(edges), 10, 0),
edapprox = TRUE, verbose = FALSE)
expect_is(est5, "netest")
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1)
init <- init.net(i.num = 10, i.num.g2 = 0)
control <- control.net(type = "SI", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est5, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$groups, 2)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
plot(x, type = "network")
plot(x, type = "network", shp.g2 = "triangle")
expect_error(plot(x, type = "network", shp.g2 = TRUE))
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1,
rec.rate = 0.1, rec.rate.g2 = 0.1)
init <- init.net(i.num = 10, i.num.g2 = 10,
r.num = 0, r.num.g2 = 0)
control <- control.net(type = "SIR", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est5, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$groups, 2)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.25,
rec.rate = 0, rec.rate.g2 = 0, act.rate = 2)
init <- init.net(i.num = 10, i.num.g2 = 10,
r.num = 0, r.num.g2 = 0)
control <- control.net(type = "SIR", nsteps = 10, nsims = 2,
verbose = FALSE)
x <- netsim(est5, param, init, control)
expect_equal(max(x$epi$ir.flow, na.rm = TRUE), 0)
expect_equal(max(x$epi$ir.flow.g2, na.rm = TRUE), 0)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.25,
rec.rate = 0.01, rec.rate.g2 = 0.01)
init <- init.net(i.num = 10, i.num.g2 = 10)
control <- control.net(type = "SIS", nsims = 2, nsteps = 25,
verbose = FALSE)
x <- netsim(est5, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$groups, 2)
expect_output(summary(x, at = 25), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.25,
rec.rate = 0, rec.rate.g2 = 0, act.rate = 2)
init <- init.net(i.num = 10, i.num.g2 = 10)
control <- control.net(type = "SIS", nsteps = 10, nsims = 2,
verbose = FALSE)
x <- netsim(est5, param, init, control)
expect_equal(max(x$epi$is.flow, na.rm = TRUE), 0)
expect_equal(max(x$epi$is.flow.g2, na.rm = TRUE), 0)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
})
test_that("Open population 1 group models", {
skip_on_cran()
nw <- network_initialize(n = 100)
est.vit <- netest(nw, formation = ~edges, target.stats = 25,
coef.diss = dissolution_coefs(~offset(edges), 10, 0.01),
verbose = FALSE)
param <- param.net(inf.prob = 0.5, act.rate = 2, a.rate = 0.01,
ds.rate = 0.01, di.rate = 0.01)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, act.rate = 2, a.rate = 0.01,
ds.rate = 0.01, di.rate = 0.01)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 2,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01,
dr.rate = 0.01)
init <- init.net(i.num = 10, r.num = 0)
control <- control.net(type = "SIR", nsteps = 10, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01,
dr.rate = 0.01)
init <- init.net(i.num = 10, r.num = 0)
control <- control.net(type = "SIR", nsteps = 10, nsims = 2,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, rec.rate = 0.01, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01)
init <- init.net(i.num = 10)
control <- control.net(type = "SIS", nsteps = 10, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
control <- control.net(type = "SIS", nsteps = 10, nsims = 2,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
})
test_that("Open-population two-group models", {
skip_on_cran()
nw <- network_initialize(n = 100, directed = FALSE)
nw <- set_vertex_attribute(nw, "group", rep(1:2, each = 50))
est5.vit <- netest(nw, formation = ~edges + nodematch("group"),
target.stats = c(25, 0),
coef.diss = dissolution_coefs(~offset(edges), 10, 0.01),
edapprox = TRUE, verbose = FALSE)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01,
a.rate.g2 = 0.01, ds.rate.g2 = 0.01, di.rate.g2 = 0.01)
init <- init.net(i.num = 10, i.num.g2 = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est5.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01,
a.rate.g2 = 0.01, ds.rate.g2 = 0.01, di.rate.g2 = 0.01)
init <- init.net(i.num = 10, i.num.g2 = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 2,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est5.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.5, inf.prob.g2 = 0.1, rec.rate = 0.1,
rec.rate.g2 = 0.1, act.rate = 2, a.rate = 0.01,
a.rate.g2 = NA, ds.rate = 0.01, ds.rate.g2 = 0.01,
di.rate = 0.01, di.rate.g2 = 0.01, dr.rate = 0.01,
dr.rate.g2 = 0.01)
init <- init.net(i.num = 10, i.num.g2 = 0,
r.num = 0, r.num.g2 = 10)
control <- control.net(type = "SIR", nsteps = 10, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est5.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
control <- control.net(type = "SIR", nsteps = 10, nsims = 2,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est5.vit, param, init, control)
expect_is(x, "netsim")
expect_is(as.data.frame(x), "data.frame")
expect_equal(x$param$vital, TRUE)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
})
test_that("Extinction open-population models", {
skip_on_cran()
nw <- network_initialize(n = 25)
nw <- set_vertex_attribute(nw, "group", rep(1:2, c(15, 10)))
est <- netest(nw, formation = ~edges + nodematch("group"),
target.stats = c(15, 0),
coef.diss = dissolution_coefs(~offset(edges), 10, 0.01),
edapprox = TRUE, verbose = FALSE)
param <- param.net(inf.prob = 0.1, inf.prob.g2 = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.5, di.rate = 0.5,
a.rate.g2 = 0.01, ds.rate.g2 = 0.01, di.rate.g2 = 0.01)
init <- init.net(i.num = 5, i.num.g2 = 0)
control <- control.net(type = "SI", nsteps = 30, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
param <- param.net(inf.prob = 0.1, inf.prob.g2 = 0.1, act.rate = 2,
a.rate = 0.01, ds.rate = 0.01, di.rate = 0.01,
a.rate.g2 = 0.01, ds.rate.g2 = 0.5, di.rate.g2 = 0.5)
init <- init.net(i.num = 5, i.num.g2 = 0)
control <- control.net(type = "SI", nsteps = 30, nsims = 1,
resimulate.network = TRUE, verbose = FALSE)
x <- netsim(est, param, init, control)
expect_output(summary(x, at = 10), "EpiModel Summary")
plot(x)
plot(x, y = "si.flow", mean.smooth = TRUE)
plot(x, type = "formation")
test_net(x)
rm(x)
})
test_that("Extended post-simulation diagnosntic tests", {
skip_on_cran()
nw <- network_initialize(n = 100)
nw <- set_vertex_attribute(nw, "risk", rep(1:5, each = 20))
est <- netest(nw,
formation = ~edges + nodefactor("risk"),
target.stats = c(50, 20, 20, 20, 20),
coef.diss = dissolution_coefs(~offset(edges), 25))
dx <- netdx(est, nsims = 2, nsteps = 10)
plot(dx)
param <- param.net(inf.prob = 0.5)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 2)
sim <- netsim(est, param, init, control)
plot(sim, type = "formation")
control <- control.net(type = "SI", nsteps = 10, nsims = 1)
sim <- netsim(est, param, init, control)
plot(sim, type = "formation")
est <- netest(nw,
formation = ~edges + concurrent,
target.stats = c(50, 20),
coef.diss = dissolution_coefs(~offset(edges), 25))
dx <- netdx(est, nsims = 5, nsteps = 100)
plot(dx)
param <- param.net(inf.prob = 0.5)
init <- init.net(i.num = 10)
control <- control.net(type = "SI", nsteps = 10, nsims = 2)
sim <- netsim(est, param, init, control)
plot(sim, type = "formation")
control <- control.net(type = "SI", nsteps = 10, nsims = 1)
sim <- netsim(est, param, init, control)
plot(sim, type = "formation")
})
test_that("status.vector and infTime.vector", {
n <- 100
nw <- network_initialize(n = n)
formation <- ~edges
target.stats <- 50
coef.diss <- dissolution_coefs(dissolution = ~offset(edges), duration = 20)
est1 <- netest(nw, formation, target.stats, coef.diss, verbose = FALSE)
param <- param.net(inf.prob = 0.3, rec.rate = 0.01)
status <- sample(c("s", "i"), size = n, replace = TRUE, prob = c(0.8, 0.2))
infTime <- rep(NA, n)
infTime[which(status == "i")] <- -rgeom(sum(status == "i"), prob = 0.01) + 2
init <- init.net(status.vector = status, infTime.vector = infTime)
control <- control.net(type = "SIS", nsteps = 100, nsims = 5, verbose.int = 0)
mod1 <- netsim(est1, param, init, control)
expect_is(mod1, "netsim")
control <- control.net(type = "SIR", nsteps = 100, nsims = 5, verbose.int = 0)
mod2 <- netsim(est1, param, init, control)
expect_is(mod2, "netsim")
})
|
frm_fb_mh_refresh_imputed_values <- function( imputations_mcmc, acc_bounds, ind0 )
{
impute_vars <- imputations_mcmc$impute_vars
NV <- imputations_mcmc$NV
mh_imputations_values <- imputations_mcmc$mh_imputations_values
if (NV > 0){
for (vv in 1:NV){
var_vv <- impute_vars[vv]
ind0_vv <- ind0[[ var_vv ]]
mh_imp_vv <- mh_imputations_values[[ var_vv ]]
mh_adapt <- ( ! is.null(mh_imp_vv) ) & ( ind0_vv$model %in% c("linreg") )
if ( mh_adapt ){
acc_pars <- list( mh_imp_vv[,1], mh_imp_vv[,2] )
res0 <- frm_proposal_refresh_helper( acceptance_parameters=acc_pars,
proposal_sd=mh_imp_vv[,3], acceptance_bounds=acc_bounds)
mh_imp_vv$sd_proposal <- res0$proposal_sd
mh_imp_vv[,1:2] <- 0 * mh_imp_vv[,1:2]
mh_imputations_values[[ var_vv ]] <- mh_imp_vv
}
}
}
imputations_mcmc$mh_imputations_values <- mh_imputations_values
return(imputations_mcmc)
}
|
mergeformulas<-function(formula1,formula2){
termsFM1<-terms(formula1)
termsFM2<-terms(formula2)
rhsvarsFM1<-attr(termsFM1,"term.labels")
rhsvarsFM2<-attr(termsFM2,"term.labels")
newterms<-rhsvarsFM2[!(rhsvarsFM2 %in% rhsvarsFM1)]
if (length(newterms)>1){
if (attr(termsFM1,"intercept")==0 & attr(termsFM2,"intercept")==1){
updateform<-as.formula(paste("~.+1+",paste(newterms,collapse = "+")))
} else {
updateform<-as.formula(paste("~.+",paste(newterms,collapse = "+")))
}
finalformula<-update(formula1,updateform)
return(finalformula)
} else {
return(formula1)
}
}
.checkbinary<-function(x){
if (sum(x==0)+sum(x==1)==length(x) & sum(x==0)>0 & sum(x==1)>0){
return(TRUE)
} else {
return(FALSE)
}
}
formula.oglmx<-function(x, ...){
if (is.null(x$formula[[2]])){
value<-x$formula[[1]]
} else {
termsFM1<-terms(x$formula[[1]])
termsFM2<-terms(x$formula[[2]])
rhsvarsFM2<-attr(termsFM2,"term.labels")
updateform<-as.formula(paste("~.|",paste(rhsvarsFM2,collapse="+")))
value<-update.formula(x$formula[[1]],updateform)
}
return(value)
}
calcstartvalues<-function(whichparameter,gfunc,threshvec){
meanstart<-numeric(sum(whichparameter[[1]]))
varstart<-numeric(sum(whichparameter[[2]]))
threshstart<-numeric(sum(whichparameter[[3]]))
if (length(varstart)>0){
calcstartdelta<-function(x){eval({z<-x;gfunc})-0.5}
varstart[1]<-uniroot(calcstartdelta,c(-10,10),extendInt="yes")$root
}
if (length(threshstart)>0){
nthresh<-length(threshvec)
if (all(is.na(threshvec))){
threshstart<-seq(from=-0.6*(nthresh/2),to=0.6*(nthresh/2),length.out=nthresh)
} else {
if (sum(!is.na(threshvec))==1){
threshstart<-threshvec[!is.na(threshvec)]+0.5*((nthresh+2)/(nthresh))*(c(1:nthresh)-c(1:nthresh)[!is.na(threshvec)])[is.na(threshvec)]
} else {
tempthreshvec<-threshvec
restrictabove<-c(sapply(c(1:(nthresh-1)),function(x){!all(is.na(threshvec[(x+1):nthresh]))}),FALSE)
restrictbelow<-c(FALSE,sapply(c(2:nthresh),function(x){!all(is.na(threshvec[1:x-1]))}))
tointerpol<-restrictabove & restrictbelow & is.na(threshvec)
if (sum(tointerpol)>0){
ranges<-sapply(c(1:nthresh)[tointerpol],function(x){c(max(threshvec[1:(x-1)],na.rm = TRUE),min(threshvec[(x+1):nthresh],na.rm=TRUE))})
if (sum(tointerpol)==1){
interpoints<-ranges
} else {interpoints<-unique(t(ranges))}
counts<-apply(interpoints,2,function(x){sum(apply(ranges,2,function(y){all(y==x)}))})
values<-do.call(c,lapply(c(1:ncol(interpoints)),function(x){seq(from=interpoints[1,x],to=interpoints[2,x],length.out = counts[x]+2)[c(-1,-(counts[x]+2))]}))
tempthreshvec[tointerpol]<-values
} else {values<-numeric()}
toextrapbelow<-!restrictbelow & is.na(threshvec)
bpoints<-sum(toextrapbelow)
if (bpoints>0){
bvalues<-tempthreshvec[bpoints+1]-sapply(c(bpoints:1),function(x){x*(tempthreshvec[bpoints+2]-tempthreshvec[bpoints+1])})
} else {bvalues<-numeric()}
toextrapabove<-!restrictabove & is.na(threshvec)
apoints<-sum(toextrapabove)
if (apoints>0){
avalues<-tempthreshvec[nthresh-apoints]+sapply(c(1:apoints),function(x){x*(tempthreshvec[nthresh-apoints]-tempthreshvec[nthresh-1-apoints])})
} else {avalues<-numeric()}
threshstart<-c(bvalues,values,avalues)
}
}
}
return(c(meanstart,varstart,threshstart))
}
calcBHHHmatrix<-function(Env){
with(Env,{
BHHHmatrix<-crossprod(scorevecs)
return(BHHHmatrix)
})
}
|
aggSentiment = function(inputData, meetingId=NULL, speakerId=NULL, sentMethod) {
aws_sentClass <- sd <- NULL
sentDt = data.table::data.table(inputData)
if(sentMethod == "aws") {
aws_sentClasses = c("POSITIVE", "NEGATIVE", "MIXED", "NEUTRAL")
awsContVars = paste0("aws_", tolower(aws_sentClasses))
awsClassVars = paste0(awsContVars, "_class")
if(sum(awsContVars %in% names(inputData)) == 0) {
stop("You have requested aws sentiment metrics, but your input data does not include aws output. Either change sentMethod to 'none' or first run textSentiment on your input data and provide the correct output data frame.")
}
sentDt[, (awsClassVars) := lapply(aws_sentClasses, function(x) aws_sentClass == x)]
if(!is.null(meetingId) && !is.null(speakerId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(mean = mean(x, na.rm=T), sd=sd(x, na.rm=T), sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(meetingId), get(speakerId)), .SDcols=c(awsContVars, awsClassVars)])
names(agg1)[1:2]= c(meetingId, speakerId)
agg1 = agg1[, c(meetingId, speakerId, paste0(awsContVars, ".mean"), paste0(awsContVars, ".sd"), paste0(awsClassVars, ".sum"), paste0(awsClassVars, ".pct"))]
} else if(!is.null(meetingId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(mean = mean(x, na.rm=T), sd=sd(x, na.rm=T), sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(meetingId)), .SDcols=c(awsContVars, awsClassVars)])
names(agg1)[1]= c(meetingId)
agg1 = agg1[, c(meetingId, paste0(awsContVars, ".mean"), paste0(awsContVars, ".sd"), paste0(awsClassVars, ".sum"), paste0(awsClassVars, ".pct"))]
} else if(!is.null(speakerId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(mean = mean(x, na.rm=T), sd=sd(x, na.rm=T), sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(speakerId)), .SDcols=c(awsContVars, awsClassVars)])
names(agg1)[1]= c(speakerId)
agg1 = agg1[, c(speakerId, paste0(awsContVars, ".mean"), paste0(awsContVars, ".sd"), paste0(awsClassVars, ".sum"), paste0(awsClassVars, ".pct"))]
} else {
stop("You did not enter either a meetingId or an speakerId")
}
sentOut = agg1
}
if(sentMethod == "syuzhet") {
syuVars = paste0("syu_",c("anger", "anticipation", "disgust", "fear", "joy", "sadness", "surprise", "trust", "negative", "positive"))
if(sum(syuVars %in% names(inputData)) == 0) {
stop("You have requested syuzhet sentiment metrics, but your input data does not include syuzhet output. Either change sentMethod to 'none' or first run textSentiment on your input data and provide the correct output data frame.")
}
if(!is.null(meetingId) && !is.null(speakerId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(meetingId), get(speakerId)), .SDcols=syuVars])
names(agg1)[1:2]= c(meetingId, speakerId)
agg1 = agg1[, c(meetingId, speakerId, paste0(syuVars, ".sum"), paste0(syuVars, ".pct"))]
} else if(!is.null(meetingId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(meetingId)), .SDcols=syuVars])
names(agg1)[1]= c(meetingId)
agg1 = agg1[, c(meetingId, paste0(syuVars, ".sum"), paste0(syuVars, ".pct"))]
} else if(!is.null(speakerId)) {
agg1 = data.frame(sentDt[, as.list(unlist(lapply(.SD, function(x) list(sum=sum(x, na.rm=T), pct=sum(x, na.rm=T)/.N)))), by=list(get(speakerId)), .SDcols=syuVars])
names(agg1)[1]= c(speakerId)
agg1 = agg1[, c(speakerId, paste0(syuVars, ".sum"), paste0(syuVars, ".pct"))]
} else {
stop("You did not enter either a meetingId or an speakerId")
}
sentOut = agg1
}
return(sentOut)
}
|
NULL
.isLambdaBasedSimulationEnabled <- function(pwsTimeObject) {
if (!pwsTimeObject$.isLambdaBased()) {
return(FALSE)
}
if (pwsTimeObject$delayedResponseEnabled) {
return(TRUE)
}
if (pwsTimeObject$piecewiseSurvivalEnabled) {
return(TRUE)
}
if (pwsTimeObject$kappa != 1) {
if (length(pwsTimeObject$lambda1) != 1) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"if 'kappa' != 1 then 'lambda1' (",
.arrayToString(pwsTimeObject$lambda1), ") must be a single numeric value"
)
}
if (length(pwsTimeObject$lambda2) != 1) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"if 'kappa' != 1 then 'lambda2' (",
.arrayToString(pwsTimeObject$lambda2), ") must be a single numeric value"
)
}
return(TRUE)
}
if (pwsTimeObject$.getParameterType("hazardRatio") == C_PARAM_USER_DEFINED &&
!all(is.na(pwsTimeObject$hazardRatio))) {
if (pwsTimeObject$.getParameterType("lambda1") == C_PARAM_USER_DEFINED &&
length(pwsTimeObject$lambda1) == length(pwsTimeObject$hazardRatio) &&
!all(is.na(pwsTimeObject$lambda1))) {
return(TRUE)
}
if (pwsTimeObject$.getParameterType("lambda2") == C_PARAM_USER_DEFINED &&
length(pwsTimeObject$lambda2) == length(pwsTimeObject$hazardRatio) &&
!all(is.na(pwsTimeObject$lambda2))) {
return(TRUE)
}
}
return(FALSE)
}
getSimulationSurvival <- function(design = NULL, ...,
thetaH0 = 1,
directionUpper = TRUE,
pi1 = NA_real_,
pi2 = NA_real_,
lambda1 = NA_real_,
lambda2 = NA_real_,
median1 = NA_real_,
median2 = NA_real_,
hazardRatio = NA_real_,
kappa = 1,
piecewiseSurvivalTime = NA_real_,
allocation1 = 1,
allocation2 = 1,
eventTime = 12L,
accrualTime = c(0L, 12L),
accrualIntensity = 0.1,
accrualIntensityType = c("auto", "absolute", "relative"),
dropoutRate1 = 0,
dropoutRate2 = 0,
dropoutTime = 12L,
maxNumberOfSubjects = NA_real_,
plannedEvents = NA_real_,
minNumberOfEventsPerStage = NA_real_,
maxNumberOfEventsPerStage = NA_real_,
conditionalPower = NA_real_,
thetaH1 = NA_real_,
maxNumberOfIterations = 1000L,
maxNumberOfRawDatasetsPerStage = 0,
longTimeSimulationAllowed = FALSE,
seed = NA_real_,
showStatistics = FALSE) {
.assertRcppIsInstalled()
if (is.null(design)) {
design <- .getDefaultDesign(..., type = "simulation")
.warnInCaseOfUnknownArguments(
functionName = "getSimulationSurvival",
ignore = c(.getDesignArgumentsToIgnoreAtUnknownArgumentCheck(
design,
powerCalculationEnabled = TRUE
), "showStatistics"), ...
)
} else {
.assertIsTrialDesign(design)
.warnInCaseOfUnknownArguments(
functionName = "getSimulationSurvival",
ignore = "showStatistics", ...
)
.warnInCaseOfTwoSidedPowerArgument(...)
}
.assertIsSingleLogical(directionUpper, "directionUpper")
.assertIsSingleNumber(thetaH0, "thetaH0")
.assertIsInOpenInterval(thetaH0, "thetaH0", 0, NULL, naAllowed = TRUE)
.assertIsNumericVector(minNumberOfEventsPerStage, "minNumberOfEventsPerStage", naAllowed = TRUE)
.assertIsNumericVector(maxNumberOfEventsPerStage, "maxNumberOfEventsPerStage", naAllowed = TRUE)
.assertIsSingleNumber(conditionalPower, "conditionalPower", naAllowed = TRUE)
.assertIsInOpenInterval(conditionalPower, "conditionalPower", 0, 1, naAllowed = TRUE)
.assertIsSingleNumber(thetaH1, "thetaH1", naAllowed = TRUE)
.assertIsInOpenInterval(thetaH1, "thetaH1", 0, NULL, naAllowed = TRUE)
.assertIsSinglePositiveInteger(maxNumberOfIterations, "maxNumberOfIterations", validateType = FALSE)
.assertIsSingleNumber(seed, "seed", naAllowed = TRUE)
.assertIsNumericVector(lambda1, "lambda1", naAllowed = TRUE)
.assertIsNumericVector(lambda2, "lambda2", naAllowed = TRUE)
.assertIsSinglePositiveInteger(maxNumberOfSubjects, "maxNumberOfSubjects",
validateType = FALSE, naAllowed = TRUE
)
.assertIsSinglePositiveInteger(allocation1, "allocation1", validateType = FALSE)
.assertIsSinglePositiveInteger(allocation2, "allocation2", validateType = FALSE)
.assertIsSingleLogical(longTimeSimulationAllowed, "longTimeSimulationAllowed")
.assertIsSingleLogical(showStatistics, "showStatistics", naAllowed = FALSE)
if (design$sided == 2) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"Only one-sided case is implemented for the survival simulation design"
)
}
if (!all(is.na(lambda2)) && !all(is.na(lambda1)) &&
length(lambda2) != length(lambda1) && length(lambda2) > 1) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT, "length of 'lambda2' (", length(lambda2),
") must be equal to length of 'lambda1' (", length(lambda1), ")"
)
}
if (all(is.na(lambda2)) && !all(is.na(lambda1))) {
warning("'lambda1' (", .arrayToString(lambda1), ") will be ignored ",
"because 'lambda2' (", .arrayToString(lambda2), ") is undefined",
call. = FALSE
)
lambda1 <- NA_real_
}
if (!all(is.na(lambda2)) && is.list(piecewiseSurvivalTime)) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"'piecewiseSurvivalTime' needs to be a numeric vector and not a list ",
"because 'lambda2' (", .arrayToString(lambda2), ") is defined separately"
)
}
thetaH1 <- .ignoreParameterIfNotUsed(
"thetaH1", thetaH1, design$kMax > 1,
"design is fixed ('kMax' = 1)", "Assumed effect"
)
if (is.na(conditionalPower) && !is.na(thetaH1)) {
warning("'thetaH1' will be ignored because 'conditionalPower' is not defined", call. = FALSE)
}
conditionalPower <- .ignoreParameterIfNotUsed(
"conditionalPower",
conditionalPower, design$kMax > 1, "design is fixed ('kMax' = 1)"
)
minNumberOfEventsPerStage <- .ignoreParameterIfNotUsed(
"minNumberOfEventsPerStage",
minNumberOfEventsPerStage, design$kMax > 1, "design is fixed ('kMax' = 1)"
)
maxNumberOfEventsPerStage <- .ignoreParameterIfNotUsed(
"maxNumberOfEventsPerStage",
maxNumberOfEventsPerStage, design$kMax > 1, "design is fixed ('kMax' = 1)"
)
minNumberOfEventsPerStage <- .assertIsValidNumberOfSubjectsPerStage(minNumberOfEventsPerStage,
"minNumberOfEventsPerStage", plannedEvents, conditionalPower, NULL, design$kMax,
endpoint = "survival", calcSubjectsFunctionEnabled = FALSE
)
maxNumberOfEventsPerStage <- .assertIsValidNumberOfSubjectsPerStage(maxNumberOfEventsPerStage,
"maxNumberOfEventsPerStage", plannedEvents, conditionalPower, NULL, design$kMax,
endpoint = "survival", calcSubjectsFunctionEnabled = FALSE
)
simulationResults <- SimulationResultsSurvival(design, showStatistics = showStatistics)
if (!is.na(conditionalPower)) {
if (design$kMax > 1) {
if (any(maxNumberOfEventsPerStage - minNumberOfEventsPerStage < 0) &&
!all(is.na(maxNumberOfEventsPerStage - minNumberOfEventsPerStage))) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT, "'maxNumberOfEventsPerStage' (",
.arrayToString(maxNumberOfEventsPerStage),
") must be not smaller than minNumberOfEventsPerStage' (",
.arrayToString(minNumberOfEventsPerStage), ")"
)
}
.setValueAndParameterType(
simulationResults, "minNumberOfEventsPerStage",
minNumberOfEventsPerStage, NA_real_
)
.setValueAndParameterType(
simulationResults, "maxNumberOfEventsPerStage",
maxNumberOfEventsPerStage, NA_real_
)
} else {
warning("'conditionalPower' will be ignored for fixed sample design", call. = FALSE)
}
} else {
simulationResults$minNumberOfEventsPerStage <- NA_real_
simulationResults$maxNumberOfEventsPerStage <- NA_real_
simulationResults$.setParameterType("minNumberOfEventsPerStage", C_PARAM_NOT_APPLICABLE)
simulationResults$.setParameterType("maxNumberOfEventsPerStage", C_PARAM_NOT_APPLICABLE)
simulationResults$.setParameterType("conditionalPower", C_PARAM_NOT_APPLICABLE)
}
if (!is.na(conditionalPower) && (design$kMax == 1)) {
warning("'conditionalPower' will be ignored for fixed sample design", call. = FALSE)
}
accrualSetup <- getAccrualTime(
accrualTime = accrualTime,
accrualIntensity = accrualIntensity,
accrualIntensityType = accrualIntensityType,
maxNumberOfSubjects = maxNumberOfSubjects
)
if (is.na(accrualSetup$maxNumberOfSubjects)) {
if (identical(accrualIntensity, 1L)) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"choose a 'accrualIntensity' > 1 or define 'maxNumberOfSubjects'"
)
}
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"'maxNumberOfSubjects' must be defined"
)
}
simulationResults$.setParameterType("seed", ifelse(is.na(seed),
C_PARAM_DEFAULT_VALUE, C_PARAM_USER_DEFINED
))
simulationResults$seed <- .setSeed(seed)
simulationResults$.accrualTime <- accrualSetup
accrualTime <- accrualSetup$.getAccrualTimeWithoutLeadingZero()
simulationResults$maxNumberOfSubjects <- accrualSetup$maxNumberOfSubjects
simulationResults$.setParameterType(
"maxNumberOfSubjects",
accrualSetup$.getParameterType("maxNumberOfSubjects")
)
simulationResults$accrualTime <- accrualSetup$.getAccrualTimeWithoutLeadingZero()
simulationResults$.setParameterType("accrualTime", accrualSetup$.getParameterType("accrualTime"))
simulationResults$accrualIntensity <- accrualSetup$accrualIntensity
simulationResults$.setParameterType(
"accrualIntensity",
accrualSetup$.getParameterType("accrualIntensity")
)
.assertIsIntegerVector(plannedEvents, "plannedEvents", validateType = FALSE)
if (length(plannedEvents) != design$kMax) {
stop(
C_EXCEPTION_TYPE_ILLEGAL_ARGUMENT,
"'plannedEvents' (", .arrayToString(plannedEvents), ") must have length ", design$kMax
)
}
.assertIsInClosedInterval(plannedEvents, "plannedEvents", lower = 1, upper = NULL)
.assertValuesAreStrictlyIncreasing(plannedEvents, "plannedEvents")
simulationResults$plannedEvents <- plannedEvents
simulationResults$.setParameterType("plannedEvents", C_PARAM_USER_DEFINED)
pwsTimeObject <- getPiecewiseSurvivalTime(
piecewiseSurvivalTime = piecewiseSurvivalTime,
lambda2 = lambda2, lambda1 = lambda1, median1 = median1, median2 = median2,
hazardRatio = hazardRatio, pi1 = pi1, pi2 = pi2, eventTime = eventTime, kappa = kappa,
delayedResponseAllowed = TRUE, .pi1Default = C_PI_1_DEFAULT
)
simulationResults$.piecewiseSurvivalTime <- pwsTimeObject
simulationResults$hazardRatio <- pwsTimeObject$hazardRatio
simulationResults$.setParameterType("hazardRatio", pwsTimeObject$.getParameterType("hazardRatio"))
simulationResults$.setParameterType("eventTime", pwsTimeObject$.getParameterType("eventTime"))
simulationResults$eventTime <- pwsTimeObject$eventTime
if (.isLambdaBasedSimulationEnabled(pwsTimeObject)) {
simulationResults$piecewiseSurvivalTime <- pwsTimeObject$piecewiseSurvivalTime
simulationResults$.setParameterType("piecewiseSurvivalTime", C_PARAM_USER_DEFINED)
simulationResults$lambda2 <- pwsTimeObject$lambda2
simulationResults$.setParameterType("lambda2", pwsTimeObject$.getParameterType("lambda2"))
lambdaVec2 <- simulationResults$lambda2
simulationResults$lambda1 <- pwsTimeObject$lambda1
simulationResults$.setParameterType("lambda1", pwsTimeObject$.getParameterType("lambda1"))
if (any(is.na(pwsTimeObject$lambda1))) {
.assertIsValidHazardRatioVector(pwsTimeObject$hazardRatio)
.setValueAndParameterType(
simulationResults, "hazardRatio",
pwsTimeObject$hazardRatio, NA_real_
)
numberOfResults <- length(simulationResults$hazardRatio)
lambdaVec1 <- simulationResults$lambda2 * pwsTimeObject$hazardRatio
} else {
numberOfResults <- 1
lambdaVec1 <- pwsTimeObject$lambda1
}
.warnInCaseOfDefinedPiValue(simulationResults, "pi1")
.warnInCaseOfDefinedPiValue(simulationResults, "pi2")
simulationResults$pi1 <- pwsTimeObject$pi1
simulationResults$pi2 <- pwsTimeObject$pi2
simulationResults$.setParameterType("pi1", pwsTimeObject$.getParameterType("pi1"))
simulationResults$.setParameterType("pi2", pwsTimeObject$.getParameterType("pi2"))
simulationResults$median1 <- pwsTimeObject$median1
simulationResults$median2 <- pwsTimeObject$median2
simulationResults$.setParameterType("median1", pwsTimeObject$.getParameterType("median1"))
simulationResults$.setParameterType("median2", pwsTimeObject$.getParameterType("median2"))
cdfValues1 <- .getPiecewiseExponentialDistribution(
pwsTimeObject$piecewiseSurvivalTime, lambdaVec1,
pwsTimeObject$piecewiseSurvivalTime,
kappa = kappa
)
cdfValues2 <- .getPiecewiseExponentialDistribution(
pwsTimeObject$piecewiseSurvivalTime, lambdaVec2,
pwsTimeObject$piecewiseSurvivalTime,
kappa = kappa
)
if (length(cdfValues1) == 1) {
cdfValues1 <- NA_real_
cdfValues2 <- NA_real_
} else {
cdfValues1 <- cdfValues1[2:length(cdfValues1)]
cdfValues2 <- cdfValues2[2:length(cdfValues2)]
}
pi1 <- NA_real_
pi2 <- NA_real_
} else {
numberOfResults <- .initDesignPlanSurvivalByPiecewiseSurvivalTimeObject(
simulationResults, pwsTimeObject
)
pi1 <- simulationResults$pi1
if (all(is.na(pi1))) {
pi1 <- getPiByLambda(simulationResults$lambda1, eventTime = eventTime, kappa = kappa)
simulationResults$pi1 <- pi1
simulationResults$.setParameterType("pi1", C_PARAM_GENERATED)
}
pi2 <- simulationResults$pi2
if (all(is.na(pi2))) {
pi2 <- getPiByLambda(simulationResults$lambda2, eventTime = eventTime, kappa = kappa)
simulationResults$pi2 <- pi2
simulationResults$.setParameterType("pi2", C_PARAM_GENERATED)
}
simulationResults$piecewiseSurvivalTime <- NA_real_
lambdaVec1 <- NA_real_
lambdaVec2 <- NA_real_
cdfValues1 <- NA_real_
cdfValues2 <- NA_real_
}
numberOfSimStepsTotal <- numberOfResults * maxNumberOfIterations *
accrualSetup$maxNumberOfSubjects
maxNumberOfSimStepsTotal <- 10 * 100000 * 100
if (numberOfSimStepsTotal > maxNumberOfSimStepsTotal) {
if (!longTimeSimulationAllowed) {
stop(
"Simulation stopped because long time simulation is disabled ",
"and the defined number of single simulation steps (", numberOfSimStepsTotal,
") is larger than the threshold ", maxNumberOfSimStepsTotal, ". ",
"Set 'longTimeSimulationAllowed = TRUE' to enable simulations ",
"that take a long time (> 30 sec)"
)
}
message(
"Note that the simulation may take a long time because ",
sprintf("%.0f", numberOfSimStepsTotal),
" single simulation steps must be calculated"
)
}
.setValueAndParameterType(simulationResults, "directionUpper", directionUpper, C_DIRECTION_UPPER_DEFAULT)
.setValueAndParameterType(simulationResults, "dropoutRate1", dropoutRate1, C_DROP_OUT_RATE_1_DEFAULT)
.setValueAndParameterType(simulationResults, "dropoutRate2", dropoutRate2, C_DROP_OUT_RATE_2_DEFAULT)
.setValueAndParameterType(simulationResults, "dropoutTime", dropoutTime, C_DROP_OUT_TIME_DEFAULT)
.setValueAndParameterType(simulationResults, "thetaH0", thetaH0, C_THETA_H0_SURVIVAL_DEFAULT)
.setValueAndParameterType(simulationResults, "allocation1", allocation1, C_ALLOCATION_1_DEFAULT)
.setValueAndParameterType(simulationResults, "allocation2", allocation2, C_ALLOCATION_2_DEFAULT)
allocationRatioPlanned <- allocation1 / allocation2
.setValueAndParameterType(
simulationResults, "allocationRatioPlanned",
allocationRatioPlanned, C_ALLOCATION_RATIO_DEFAULT
)
.setValueAndParameterType(simulationResults, "conditionalPower", conditionalPower, NA_real_)
if (!is.na(thetaH0) && !is.na(thetaH1) && thetaH0 != 1) {
thetaH1 <- thetaH1 / thetaH0
.setValueAndParameterType(simulationResults, "thetaH1", thetaH1, NA_real_)
simulationResults$.setParameterType("thetaH1", C_PARAM_GENERATED)
} else {
.setValueAndParameterType(simulationResults, "thetaH1", thetaH1, NA_real_)
}
if (is.na(conditionalPower)) {
simulationResults$.setParameterType("thetaH1", C_PARAM_NOT_APPLICABLE)
}
.setValueAndParameterType(simulationResults, "kappa", kappa, 1)
.setValueAndParameterType(
simulationResults, "maxNumberOfIterations",
as.integer(maxNumberOfIterations), C_MAX_SIMULATION_ITERATIONS_DEFAULT
)
phi <- -c(log(1 - dropoutRate1), log(1 - dropoutRate2)) / dropoutTime
densityIntervals <- accrualTime
if (length(accrualTime) > 1) {
densityIntervals[2:length(accrualTime)] <-
accrualTime[2:length(accrualTime)] - accrualTime[1:(length(accrualTime) - 1)]
}
densityVector <- accrualSetup$accrualIntensity / sum(densityIntervals * accrualSetup$accrualIntensity)
intensityReplications <- round(densityVector * densityIntervals * accrualSetup$maxNumberOfSubjects)
if (all(intensityReplications > 0)) {
accrualTimeValue <- cumsum(rep(
1 / (densityVector * accrualSetup$maxNumberOfSubjects), intensityReplications
))
} else {
accrualTimeValue <- cumsum(rep(
1 / (densityVector[1] * accrualSetup$maxNumberOfSubjects),
intensityReplications[1]
))
if (length(accrualIntensity) > 1) {
for (i in 2:length(accrualIntensity)) {
if (intensityReplications[i] > 0) {
accrualTimeValue <- c(accrualTimeValue, accrualTime[i - 1] +
cumsum(rep(
1 / (densityVector[i] * accrualSetup$maxNumberOfSubjects),
intensityReplications[i]
)))
}
}
}
}
accrualTimeValue <- accrualTimeValue[1:accrualSetup$maxNumberOfSubjects]
i <- accrualSetup$maxNumberOfSubjects
while (is.na(accrualTimeValue[i])) {
accrualTimeValue[i] <- accrualTime[length(accrualTime)]
i <- i - 1
}
treatmentGroup <- rep(
c(rep(1, allocation1), rep(2, allocation2)),
ceiling(accrualSetup$maxNumberOfSubjects /
(allocation1 + allocation2))
)[1:accrualSetup$maxNumberOfSubjects]
if (.isTrialDesignFisher(design)) {
alpha0Vec <- design$alpha0Vec
futilityBounds <- rep(NA_real_, design$kMax - 1)
} else {
alpha0Vec <- rep(NA_real_, design$kMax - 1)
futilityBounds <- design$futilityBounds
}
if (.isTrialDesignGroupSequential(design)) {
designNumber <- 1L
} else if (.isTrialDesignInverseNormal(design)) {
designNumber <- 2L
} else if (.isTrialDesignFisher(design)) {
designNumber <- 3L
}
resultData <- getSimulationSurvivalCpp(
designNumber = designNumber,
kMax = design$kMax,
sided = design$sided,
criticalValues = design$criticalValues,
informationRates = design$informationRates,
conditionalPower = conditionalPower,
plannedEvents = plannedEvents,
thetaH1 = thetaH1,
minNumberOfEventsPerStage = minNumberOfEventsPerStage,
maxNumberOfEventsPerStage = maxNumberOfEventsPerStage,
directionUpper = directionUpper,
allocation1 = allocation1,
allocation2 = allocation2,
accrualTime = accrualTimeValue,
treatmentGroup = treatmentGroup,
thetaH0 = thetaH0,
futilityBounds = futilityBounds,
alpha0Vec = alpha0Vec,
pi1Vec = pi1,
pi2 = pi2,
eventTime = eventTime,
piecewiseSurvivalTime = .getPiecewiseExpStartTimesWithoutLeadingZero(pwsTimeObject$piecewiseSurvivalTime),
cdfValues1 = cdfValues1,
cdfValues2 = cdfValues2,
lambdaVec1 = lambdaVec1,
lambdaVec2 = lambdaVec2,
phi = phi,
maxNumberOfSubjects = accrualSetup$maxNumberOfSubjects,
maxNumberOfIterations = maxNumberOfIterations,
maxNumberOfRawDatasetsPerStage = maxNumberOfRawDatasetsPerStage,
kappa = kappa
)
overview <- resultData$overview
if (length(overview) == 0 || nrow(overview) == 0) {
stop(C_EXCEPTION_TYPE_RUNTIME_ISSUE, "no simulation results calculated")
}
n <- nrow(overview)
overview <- cbind(
design = rep(sub("^TrialDesign", "", class(design)), n),
overview
)
if (pwsTimeObject$.isPiBased() &&
pwsTimeObject$.getParameterType("hazardRatio") != C_PARAM_USER_DEFINED) {
simulationResults$hazardRatio <- matrix(overview$hazardRatio, nrow = design$kMax)[1, ]
}
simulationResults$iterations <- matrix(as.integer(overview$iterations), nrow = design$kMax)
if (!is.null(overview$eventsPerStage)) {
simulationResults$eventsPerStage <- matrix(overview$eventsPerStage, nrow = design$kMax)
}
simulationResults$eventsNotAchieved <- matrix(overview$eventsNotAchieved, nrow = design$kMax)
if (any(simulationResults$eventsNotAchieved > 0)) {
warning("Presumably due to drop-outs, required number of events ",
"were not achieved for at least one situation. ",
"Increase the maximum number of subjects (",
accrualSetup$maxNumberOfSubjects, ") ",
"to avoid this situation",
call. = FALSE
)
}
simulationResults$numberOfSubjects <- matrix(overview$numberOfSubjects, nrow = design$kMax)
simulationResults$numberOfSubjects1 <-
.getNumberOfSubjects1(simulationResults$numberOfSubjects, allocationRatioPlanned)
simulationResults$numberOfSubjects2 <-
.getNumberOfSubjects2(simulationResults$numberOfSubjects, allocationRatioPlanned)
if (allocationRatioPlanned != 1) {
simulationResults$.setParameterType("numberOfSubjects1", C_PARAM_GENERATED)
simulationResults$.setParameterType("numberOfSubjects2", C_PARAM_GENERATED)
}
simulationResults$overallReject <- matrix(overview$overallReject, nrow = design$kMax)[1, ]
if (design$kMax > 1) {
simulationResults$rejectPerStage <- matrix(overview$rejectPerStage, nrow = design$kMax)
} else {
simulationResults$rejectPerStage <- matrix(simulationResults$overallReject, nrow = 1)
}
if (!all(is.na(overview$conditionalPowerAchieved))) {
simulationResults$conditionalPowerAchieved <- matrix(
overview$conditionalPowerAchieved,
nrow = design$kMax
)
simulationResults$.setParameterType("conditionalPowerAchieved", C_PARAM_GENERATED)
}
if (design$kMax == 1) {
simulationResults$.setParameterType("numberOfSubjects", C_PARAM_NOT_APPLICABLE)
simulationResults$.setParameterType("eventsPerStage", C_PARAM_NOT_APPLICABLE)
}
if (design$kMax > 1) {
if (numberOfResults == 1) {
simulationResults$futilityPerStage <- matrix(
overview$futilityPerStage[1:(design$kMax - 1)],
nrow = design$kMax - 1
)
} else {
simulationResults$futilityPerStage <- matrix(matrix(
overview$futilityPerStage,
nrow = design$kMax
)[1:(design$kMax - 1), ],
nrow = design$kMax - 1
)
}
}
if (design$kMax > 1) {
simulationResults$futilityStop <- matrix(overview$futilityStop, nrow = design$kMax)[1, ]
simulationResults$earlyStop <- simulationResults$futilityStop +
simulationResults$overallReject - simulationResults$rejectPerStage[design$kMax, ]
} else {
simulationResults$futilityStop <- rep(0, numberOfResults)
simulationResults$earlyStop <- rep(0, numberOfResults)
}
simulationResults$analysisTime <- matrix(overview$analysisTime, nrow = design$kMax)
simulationResults$studyDuration <- matrix(overview$studyDuration, nrow = design$kMax)[1, ]
if (design$kMax > 1) {
subData <- simulationResults$rejectPerStage[1:(design$kMax - 1), ] +
simulationResults$futilityPerStage
pStop <- rbind(subData, 1 - colSums(subData))
numberOfSubjects <- simulationResults$numberOfSubjects
numberOfSubjects[is.na(numberOfSubjects)] <- 0
simulationResults$expectedNumberOfSubjects <- diag(t(numberOfSubjects) %*% pStop)
if (!is.null(simulationResults$eventsPerStage) &&
nrow(simulationResults$eventsPerStage) > 0 &&
ncol(simulationResults$eventsPerStage) > 0) {
simulationResults$eventsPerStage <- .convertStageWiseToOverallValues(
simulationResults$eventsPerStage
)
simulationResults$expectedNumberOfEvents <-
diag(t(simulationResults$eventsPerStage) %*% pStop)
}
} else {
simulationResults$expectedNumberOfSubjects <-
as.numeric(simulationResults$numberOfSubjects)
if (!is.null(simulationResults$eventsPerStage) &&
nrow(simulationResults$eventsPerStage) > 0 &&
ncol(simulationResults$eventsPerStage) > 0) {
simulationResults$expectedNumberOfEvents <-
as.numeric(simulationResults$eventsPerStage)
}
}
if (is.null(simulationResults$expectedNumberOfEvents) ||
length(simulationResults$expectedNumberOfEvents) == 0) {
warning("Failed to calculate expected number of events", call. = FALSE)
}
data <- resultData$data[!is.na(resultData$data$iterationNumber), ]
data$trialStop <- (data$rejectPerStage == 1 | data$futilityPerStage == 1 |
data$stageNumber == design$kMax)
if (!is.null(data$eventsPerStage) && !any(is.nan(data$eventsPerStage))) {
if (directionUpper) {
data$hazardRatioEstimateLR <- exp(data$logRankStatistic *
(1 + allocation1 / allocation2) / sqrt(allocation1 / allocation2 *
data$eventsPerStage))
} else {
data$hazardRatioEstimateLR <- exp(-data$logRankStatistic *
(1 + allocation1 / allocation2) / sqrt(allocation1 / allocation2 *
data$eventsPerStage))
}
}
simulationResults$.data <- data
stages <- 1:design$kMax
rawData <- resultData$rawData
if (!is.null(rawData) && nrow(rawData) > 0 && ncol(rawData) > 0) {
rawData <- rawData[!is.na(rawData$iterationNumber), ]
}
if (!is.null(rawData) && nrow(rawData) > 0 && ncol(rawData) > 0) {
stopStageNumbers <- rawData$stopStage
missingStageNumbers <- c()
if (length(stopStageNumbers) > 0) {
stopStageNumbers <- order(unique(stopStageNumbers))
missingStageNumbers <- stages[!which(stages %in% stopStageNumbers)]
} else {
missingStageNumbers <- stages
}
if (length(missingStageNumbers) > 0) {
warning("Could not get rawData (individual results) for stages ",
.arrayToString(missingStageNumbers),
call. = FALSE
)
}
} else {
rawData <- data.frame(
iterationNumber = numeric(0),
stopStage = numeric(0),
pi1 = numeric(0),
pi2 = numeric(0),
subjectId = numeric(0),
accrualTime = numeric(0),
treatmentGroup = numeric(0),
survivalTime = numeric(0),
dropoutTime = numeric(0),
observationTime = numeric(0),
timeUnderObservation = numeric(0),
event = logical(0),
dropoutEvent = logical(0),
censorIndicator = numeric(0)
)
if (maxNumberOfRawDatasetsPerStage > 0) {
warning("Could not get rawData (individual results) for stages ",
.arrayToString(stages),
call. = FALSE
)
}
}
if (pwsTimeObject$.isLambdaBased() || length(pi1) < 2) {
rawData <- rawData[, !(colnames(rawData) %in% c("pi1", "pi2"))]
}
rawData <- rawData[, colnames(rawData) != "censorIndicator"]
simulationResults$.rawData <- rawData
return(simulationResults)
}
|
salbm <- function( data, Narm = length(data), K, ntree,
seeds = 1:length(data), seeds2 = -1 - 1:length(data),
alphas, NBootstraps = 0, bBS = 1,
returnJP = TRUE, returnSamples = FALSE)
{
ns <- length(seeds)
ns2 <- length(seeds2)
if ( ns < Narm ) seeds <- c( seeds, seeds [ns ] + 1:(Narm-ns ))
if ( ns2 < Narm ) seeds2 <- c( seeds2, seeds2[ns2] - 1:(Narm-ns2))
eBS <- bBS + NBootstraps - 1
for ( trt in 1:Narm ) {
tdat <- data[[trt]]
tdat[ is.na(tdat) ] <- 2
data[[trt]] <- tdat
}
Ret <- list( data = data, Narm = Narm, K = K, ntree = ntree,
seeds = seeds, seeds2 = seeds2, alphas = alphas,
bBS = bBS, eBS = eBS, NBootstraps = NBootstraps)
Ret[["mna" ]] <- min(alphas)
Ret[["mxa" ]] <- max(alphas)
for ( trt in 1:Narm ) {
sd <- seeds2[trt]
tdat <- data[[trt]]
nr <- nrow(tdat)
wts <- wtsDat( tdat, sub = 0, trt = trt)
tdat[] <- lapply(tdat, function(x) factor(x, levels=c("0","1","2")))
jp <- rfjp( data = tdat, ntree = ntree, seed = sd, nodesize = 1 )
tiltRes <- lapply( alphas, function(x) tilt(x, jp) )
trtR <- do.call(rbind,tiltRes)
trtR <- as.data.frame(trtR)
names(trtR) <- c("alpha", paste( "E", 1:K, sep=""), paste( "Esum", 1:K, sep=""))
trtRL <- mkRLong( trtR, K, trt=trt )
nms <- c( paste0("Main",trt,"R"), paste0("Main",trt,"RL"), paste0("Main",trt,"wts") )
Ret[[nms[1]]] <- trtR
Ret[[nms[2]]] <- trtRL
Ret[[nms[3]]] <- wts
if ( returnJP ) {
Ret[[ paste0("JP",trt) ]] <- jp
}
if ( NBootstraps > 0 ) {
set.seed( seeds[trt] )
llout <- lapply( bBS:eBS, oneSamp, jps=jp, nsamp = nr, K = K,
sd = sd, ntree = ntree, alphas = alphas, trt = trt,
returnSamples = returnSamples)
SampR <- lapply(llout,function(x) { return(x$SampR ) } )
SampRL <- lapply(llout,function(x) { return(x$SampRL ) } )
Sampwts <- lapply(llout,function(x) { return(x$wtsSamp ) } )
SampR <- do.call(rbind,SampR)
SampRL <- do.call(rbind,SampRL)
Sampwts <- do.call(rbind,Sampwts)
nms <- c( paste0("Samp",trt,"R"), paste0("Samp",trt,"RL"),
paste0("Samp",trt,"wts"), paste0("Samp",trt))
Ret[[nms[1]]] <- SampR
Ret[[nms[2]]] <- SampRL
Ret[[nms[3]]] <- Sampwts
if ( returnSamples ) {
Samp <- lapply(llout,function(x) { return(x$Samp ) } )
Samp <- do.call(rbind,Samp)
Ret[[nms[4]]] <- Samp
}
}
}
class(Ret) <- c("salbm")
return(Ret)
}
|
rmtruncnorm <- function(n, mean, varcov, lower, upper) {
d <- if(is.matrix(varcov)) ncol(varcov) else 1
if(missing(lower)) lower <- rep(-Inf, d)
if(missing(upper)) upper <- rep(Inf, d)
tmvnsim(n, d, lower, upper, rep(FALSE, d), mean, varcov)$samp
}
dmtruncnorm <- function(x, mean, varcov, lower, upper, log= FALSE, ...) {
d <- if(is.matrix(varcov)) ncol(varcov) else 1
if(d > 20) stop("the maximal dimension is 20")
x <- if (is.vector(x)) t(matrix(x)) else data.matrix(x)
if(ncol(x) != d) stop("mismatch of the dimensions of 'x' and 'varcov'")
if(is.matrix(mean)) {
if((nrow(x) != nrow(mean)) || (ncol(mean) != d))
stop("mismatch of dimensions of 'x' and 'mean'")}
if(missing(lower)) lower <- rep(-Inf,d)
if(missing(upper)) upper <- rep(Inf,d)
if(length(lower) != d | length(upper) != d) stop("dimension mismatch")
if(!all(lower < upper)) stop("lower<upper componentwise is required")
ok <- apply((t(x)-lower)>0 & (upper-t(x))>0, 2, all)
pdf <- rep(0, NROW(x))
if(sum(ok) > 0) {
prob <- sadmvn(lower, upper, mean, varcov, ...)
tmp <- dmnorm(x[ok,], mean, varcov, log=log)
pdf[ok] <- if(log) tmp - log(prob) else tmp/prob
}
return(pdf)
}
pmtruncnorm <- function(x, mean, varcov, lower, upper, ...) {
d <- if(is.matrix(varcov)) ncol(varcov) else 1
if(d > 20) stop("the maximal dimension is 20")
x <- if (is.vector(x)) t(matrix(x)) else data.matrix(x)
if (ncol(x) != d) stop("mismatch of dimensions of 'x' and 'varcov'")
if (is.matrix(mean)) {
if ((nrow(x) != nrow(mean)) || (ncol(mean) != d))
stop("mismatch of dimensions of 'x' and 'mean'") }
if(missing(lower)) lower <- rep(-Inf,d)
if(missing(upper)) upper <- rep(Inf,d)
if(length(lower) != d | length(upper) != d) stop("dimension mismatch")
if(!all(lower < upper)) stop("lower<upper componentwise is required")
n <- NROW(x)
p <- numeric(n)
for(i in 1:n) p[i] <- if(any(x[i,] < lower)) 0 else
sadmvn(lower, pmin(x[i,], upper), mean, varcov)
return(p/sadmvn(lower, upper, mean, varcov, ...))
}
mom.mtruncnorm <- function(powers=4, mean, varcov, lower, upper, cum=TRUE, ...)
{
d <- if(is.matrix(varcov)) ncol(varcov) else 1
if(d > 20) stop("maximal dimension is 20")
if(any(powers < 0) | any(powers != round(powers)))
stop("'powers' must be non-negative integers")
if(length(powers) == 1) powers <- rep(powers, d)
if(missing(lower)) lower <- rep(-Inf,d)
if(missing(upper)) upper <- rep(Inf,d)
if(!all(lower < upper)) stop("lower<upper is required")
if(!all(c(length(powers) == d, length(lower) == d, length(upper) == d,
length(mean) == d, dim(varcov) == c(d,d)))) stop("dimension mismatch")
if(any(lower >= upper)) stop("non-admissible bounds")
M <- recintab(kappa=powers, a=lower, b=upper, mean, varcov, ...)
mom <- M/M[1]
out <- list(mom=mom)
cum <- if(cum) mom2cum(mom) else NULL
return(c(out, cum))
}
mom2cum <- function(mom)
{
get.entry <- function(array, subs, val) {
x <- get(array)
ind <- rep(1, length(dim(x)))
ind[subs] <- val + 1
subs.char <- paste(as.character(ind), collapse=",")
eval(str2expression(paste(array, "[", subs.char, "]", sep="")))
}
if(is.na(mom[1])) return(list(cum=NA, message="mom[1] must be 1"))
if(mom[1] != 1) return(list(cum=NA, message="mom[1] must be 1"))
if(is.vector(mom)) {
m <- mom[-1]
powers <- length(m)
cum <- cmom <- g1 <- g2 <- NULL
if(powers >= 1) {
cum <- m[1]
cmom <- 0
}
if(powers >= 2) {
cum <- c(cum, m[2] - m[1]^2)
if(cum[2] <= 0 ) warning("cum[2] <= 0")
cmom <- c(cmom, cum[2])
}
if(powers >= 3) {
cum <- c(cum, m[3] -3*m[1]*m[2] + 2*m[1]^3)
cmom <- c(cmom, cum[3])
g1 <- cum[3]/cum[2]^1.5
}
if(powers >= 4) {
cum <- c(cum, m[4] -3*m[2]^2 - 4*m[1]*m[3] + 12*m[1]^2*m[2] -6*m[1]^4)
cmom <- c(cmom, cum[4] + 3*cum[2]^2)
g2 <- cum[4]/cum[2]^2
}
out <- list(cum=cum, centr.mom=cmom, std.cum=c(gamma1=g1, gamma2=g2))
return(out)
}
powers <- dim(mom) - 1
d <- length(powers)
out <- list()
if(all(powers >= 1)) {
m1 <- numeric(d)
for(i in 1:d) m1[i] <- get.entry("mom", i, 1)
out$cum1 <- m1
}
if(all(powers >= 2)) {
m2 <- matrix(0, d, d)
for(i in 1:d) for(j in 1:d)
m2[i,j] <- if(i == j)
get.entry("mom", i, 2) else get.entry("mom", c(i, j), c(1,1))
vcov <- cum2 <- (m2 - m1 %*% t(m1))
if(any(eigen(cum2, symmetric=TRUE, only.values=TRUE)$values <= 0))
warning("matrix 'cum2' not positive-definite")
conc <- pd.solve(vcov, silent=TRUE, log.det=TRUE)
log.det <- attr(conc, "log.det")
attr(conc, 'log.det') <- NULL
out$order2 <- list(m2=m2, cum2=vcov, conc.matrix=conc, log.det.cum2=log.det)
if(is.null(conc)) {
out$message <- "Warning: input array 'mom' appears problematic"
return(out)
}
}
if(all(powers >= 3)) {
mom2 <- m2[cbind(1:d,1:d)]
cmom2 <- vcov[cbind(1:d,1:d)]
cmom3 <- mom3 <- numeric(d)
m3 <- array(NA, rep(d,3))
for(i in 1:d) for (j in 1:d) for(k in 1:d) {
if(i==j & j==k) {
subs <- i
val <- 3
mom3[i] <- get.entry("mom", subs, val)
cmom3[i] <- mom3[i] - 3*m1[i]*mom2[i] + 2*m1[i]^3
}
else {
if (i==j | i==k | j==k) {
val <- c(2,1)
if(i==j) subs <- c(i,k)
if(i==k) subs <- c(i,j)
if(j==k) subs <- c(j,i)
} else {
subs <- c(i,j,k)
val <- c(1,1,1)
}
}
m3[i,j,k] <- get.entry("mom", subs, val)
}
cum3 <- array(NA, rep(d, 3))
for(i in 1:d) for (j in 1:d) for(k in 1:d)
cum3[i,j,k] <- (m3[i,j,k]
- (m1[i]*m2[j,k] + m1[j]*m2[i,k] + m1[k]*m2[i,j])
+ 2 * m1[i]*m1[j]*m1[k])
g1 <- 0
for(i in 1:d) for (j in 1:d) for(k in 1:d)
for(l in 1:d) for (m in 1:d) for(n in 1:d)
g1 <- g1 + cum3[i,j,k]*cum3[l,m,n]*conc[i,l]*conc[j,m]*conc[k,n]
out$order3 <- list(m3=m3, cum3=cum3, m3.marginal=mom3,
centr.mom3.marginal=cmom3, gamma1.marginal=cmom3/cmom2^(3/2),
gamma1.Mardia=g1, beta1.Mardia=g1)
}
if(all(powers >= 4)) {
cmom4 <- mom4 <- numeric(d)
m4 <- array(NA, rep(d,4))
for(i in 1:d) for (j in 1:d) for(k in 1:d) for(l in 1:d) {
if(i==j & j==k & k == l) {
val <- 4
subs <- i
mom4[i] <- get.entry("mom", subs, val)
cmom4[i] <- mom4[i] - 4*m1[i]*mom3[i] + 6*m1[i]^2*mom2[i] - 3*m1[i]^4
}
else { if(i==j & j==k | i==k & k==l | i==j & j==l | j==k & k==l) {
val <- c(3, 1)
if(i==j & j==k) subs <- c(i,l)
if(i==k & k==l) subs <- c(i,j)
if(i==j & j==l) subs <- c(i,k)
if(j==k & k==l) subs <- c(j,i)
}
else { if(i==j & k==l | i==k & j==l | i==l & j==k) {
val <- c(2, 2)
if(i==j & k==l) subs <- c(i,k)
if(i==k & j==l) subs <- c(i,j)
if(i==l & j==k) subs <- c(i,j)
}
else { if(i==j | i==k | i==l | j==k | j==l | k==l) {
val <- c(2, 1, 1)
if(i==j) subs <- c(i,k,l)
if(i==k) subs <- c(i,j,l)
if(i==l) subs <- c(i,j,k)
if(j==k) subs <- c(j,i,l)
if(j==l) subs <- c(j,i,k)
if(k==l) subs <- c(k,i,j)
}
else {
val <- c(1,1,1,1)
subs <- c(i,j,k,l)
}}}}
m4[i,j,k,l] <- get.entry("mom", subs, val)
}
cum4 <- array(NA, rep(d, 4))
for(i in 1:d) for (j in 1:d) for(k in 1:d) for(l in 1:d)
cum4[i,j,k,l] <- ( m4[i,j,k,l]
-(m1[i]*m3[j,k,l] + m1[j]*m3[i,k,l] + m1[k]*m3[i,j,l] + m1[l]*m3[i,j,k])
-(m2[i,j]*m2[k,l] + m2[i,k]*m2[j,l] + m2[i,l]*m2[j,k])
+2 * (m1[i]*m1[j]*m2[k,l] + m1[i]*m1[k]*m2[j,l] + m1[i]*m1[l]*m2[j,k] +
m1[j]*m1[k]*m2[i,l] + m1[j]*m1[l]*m2[i,k] + m1[k]*m1[l]*m2[i,j])
-6 * m1[i]*m1[j]*m1[k]*m1[l] )
g2 <- 0
for(i in 1:d) for (j in 1:d) g2 <- g2 + cum4[i,j,,] * conc * conc[i,j]
g2 <- sum(g2)
b2 <- g2 + d*(d+2)
out$order4 <- list(m4=m4, cum4=cum4, m4.marginal=mom4,
centr.mom4.marginal=cmom4, gamma2.marginal=(cmom4/cmom2^2 - 3),
gamma2.Mardia=g2, beta2.Mardia=b2)
}
return(out)
}
recintab <- function(kappa, a, b, mu, S, ...)
{
if(!all(a < b)) stop("a<b is required")
d <- n <- length(kappa);
if (n == 1) {
M <- rep(0, kappa+1)
s1 <- sqrt(S);
aa <- (a - mu)/s1;
bb <- (b - mu)/s1;
M[1] <- pnorm(bb) - pnorm(aa);
if (kappa > 0) {
pdfa <- s1*dnorm(aa);
pdfb <- s1*dnorm(bb);
M[2] <- mu*M[1] + pdfa - pdfb;
if(is.infinite(a)) a <- 0;
if(is.infinite(b)) b <- 0;
if(kappa > 1) for(i in 2:kappa) {
pdfa <- pdfa*a;
pdfb <- pdfb*b;
M[i+1] <- mu*M[i] + (i-1)*S*M[i-1] + pdfa - pdfb;
}}}
else {
M <- array(0, dim=kappa+1);
pk <- prod(kappa+1);
nn <- round(pk/(kappa+1));
begind <- cumsum(c(0, nn));
pk1 <- begind[n+1];
cp <- matrix(0, n, n);
for(i in 1:n) {
kk <- kappa;
kk[i] <- 0;
cp[i,] <- c(1, cumprod(kk[1:(n-1)] + 1));
}
G <- rep(0, pk1);
H <- rep(0, pk1);
s <- sqrt(diag(S));
pdfa <- dnorm(a, mu, s)
pdfb <- dnorm(b, mu, s)
for(i in 1:n) {
ind2 <- (1:n)[-i];
kappai <- kappa[ind2];
ai <- a[ind2];
bi <- b[ind2];
mui <- mu[ind2];
Si <- S[ind2,i];
SSi <- S[ind2,ind2] - Si %*% t(Si)/S[i,i];
ind <- (begind[i]+1):begind[i+1];
if(a[i] > -Inf) {
mai <- mui + Si/S[i,i] * (a[i]-mu[i]);
G[ind] <- pdfa[i] * recintab(kappai, ai, bi, mai, SSi);
}
if(b[i] < Inf ) {
mbi <- mui + Si/S[i,i] * (b[i]-mu[i]);
H[ind] <- pdfb[i] * recintab(kappai, ai, bi, mbi, SSi);
}
}
M[1] <- sadmvn(a, b, mu, S, ...)
a[is.infinite(a)] <- 0;
b[is.infinite(b)] <- 0;
cp1 <- t(cp[n,,drop=FALSE]);
for(i in 2:pk) {
kk <- arrayInd(i, kappa+1)
ii <- (kk-1) %*% cp1 + 1;
i1 <- min(which(kk>1));
kk1 <- kk;
kk1[i1] <- kk1[i1] - 1;
ind3 <- ii - cp1[i1];
M[ii] <- mu[i1] %*% M[ind3];
for(j in 1:n) {
kk2 <- kk1[j] - 1;
if(kk2 > 0)
M[ii] <- M[ii] + S[i1,j] %*% kk2 %*% M[ind3-cp1[j]];
ind4 <- begind[j] + cp[j,] %*% t(kk1-1) - cp[j,j]*kk2 + 1;
M[ii] <- M[ii] + S[i1,j] %*% (a[j]^kk2*G[ind4] -b[j]^kk2*H[ind4]);
}
}
}
return(M)
}
dmtrunct <- function(x, mean, S, df, lower, upper, log= FALSE, ...) {
if(df == Inf) return(dmtruncnorm(x, mean, S, log = log))
d <- if(is.matrix(S)) ncol(S) else 1
x <- if (is.vector(x)) t(matrix(x)) else data.matrix(x)
if(ncol(x) != d) stop("mismatch of dimensions of 'x' and 'S'")
if(is.matrix(mean)) {
if((nrow(x) != nrow(mean)) || (ncol(mean) != d))
stop("mismatch of dimensions of 'x' and 'mean'")}
if(missing(lower)) lower <- rep(-Inf,d)
if(missing(upper)) upper <- rep(Inf,d)
if(length(lower) != d | length(upper) != d) stop("dimension mismatch")
if(!all(lower < upper)) stop("lower<upper is required")
ok <- apply((t(x)-lower)>0 & (upper-t(x))>0, 2, all)
pdf <- rep(0, NROW(x))
if(sum(ok) > 0) {
prob <- sadmvt(df, lower, upper, mean, S, ...)
tmp <- dmt(x[ok,], mean, S, df, log=log)
pdf[ok] <- if(log) tmp - log(prob) else tmp/prob
}
return(pdf)
}
pmtrunct <- function(x, mean, S, df, lower, upper, ...) {
if(df == Inf) return(pmtruncnorm(x, mean, S, log = log))
d <- if(is.matrix(S)) ncol(S) else 1
if(d > 20) stop("maximal dimension is 20")
x <- if (is.vector(x)) t(matrix(x)) else data.matrix(x)
if (ncol(x) != d) stop("mismatch of dimensions of 'x' and 'S'")
if (is.matrix(mean)) {
if ((nrow(x) != nrow(mean)) || (ncol(mean) != d))
stop("mismatch of dimensions of 'x' and 'mean'") }
if(missing(lower)) lower <- rep(-Inf,d)
if(missing(upper)) upper <- rep(Inf,d)
if(length(lower) != d | length(upper) != d) stop("dimension mismatch")
if(!all(lower < upper)) stop("lower<upper is required")
n <- NROW(x)
p <- numeric(n)
for(i in 1:n) p[i] <- if(any(x[i,] < lower)) 0 else
sadmvt(df, lower, pmin(x[i,], upper), mean, S, ...)
return(p/sadmvt(df,lower, upper, mean, S, ...))
}
|
draw.bg = function(
start,
end,
ylab = "",
ysub = as.character(NA),
mar = c(0.2, 5, 0.2, 1),
xaxt = "s",
yaxt = "n",
yaxs = "r",
ylim = c(0, 1),
cex.lab = 1,
cex.axis = 1,
mgp = c(3, 1, 0),
tck = NA,
tcl = -0.5,
xaxp = as.numeric(NA),
yaxp = as.numeric(NA),
bty = "o",
las = 0,
xgrid = TRUE,
new = FALSE,
...
) {
if(is.numeric(start)) start <- as.integer(start)
if(is.numeric(end)) end <- as.integer(end)
if(!is.integer(start)) stop("'start' must be integer or numeric")
if(!is.integer(end)) stop("'end' must be integer or numeric")
if(start == -1) start <- 0L
if(any(is.na(xaxp))) xaxp <- NULL
if(any(is.na(yaxp))) yaxp <- NULL
graphics::par(cex=1, mar=mar, new=new)
graphics::plot(
x=NA, y=NA,
xlim = c(start, end),
ylim = ylim,
xlab = "",
xaxt = "n",
xaxs = "i",
ylab = ylab,
yaxt = yaxt,
yaxs = yaxs,
yaxp = yaxp,
bty = "n",
las = las,
cex.lab = cex.lab,
cex.axis = cex.axis,
mgp = mgp,
tck = tck,
tcl = tcl
)
if(yaxt == "n" && !is.na(ysub)) {
graphics::mtext(
side = 2,
text = ysub,
line = 1,
adj = 0.5,
cex = cex.lab
)
}
if(length(xaxp) != 3L) { at <- pretty(c(start, end), n=12)
} else { at <- pretty(c(xaxp[1], xaxp[2]), n=xaxp[3])
}
if(xaxt != "n") {
if(isTRUE(xgrid)) { graphics::axis(side=1, at=at, las=las, tck=1, col="
} else { graphics::axis(side=1, at=at, las=las, cex.axis=cex.axis, labels=at/1e6, padj=-1)
}
} else {
if(isTRUE(xgrid)) { graphics::axis(side=1, at=at, las=las, tck=1, col="
}
}
graphics::box(
which = "plot",
col = "
bty = bty
)
}
|
library(tidyverse)
library(dbplyr)
library(dm)
set.seed(20200314)
library(DBI)
mydb <- dbConnect(
RMariaDB::MariaDB(),
username = "guest",
password = "relational",
dbname = "Financial_ijs",
host = "relational.fit.cvut.cz"
)
mydm <- dm_from_src(mydb, learn_keys = FALSE)
financial_dm <- function(mydb) {
mydm %>%
dm_add_pk(districts, id) %>%
dm_add_pk(accounts, id) %>%
dm_add_pk(clients, id) %>%
dm_add_pk(loans, id) %>%
dm_add_pk(orders, id) %>%
dm_add_pk(trans, id) %>%
dm_add_pk(disps, id) %>%
dm_add_pk(cards, id) %>%
dm_add_fk(
loans, account_id,
accounts
) %>%
dm_add_fk(
orders, account_id,
accounts
) %>%
dm_add_fk(
trans, account_id,
accounts
) %>%
dm_add_fk(
disps, account_id,
accounts
) %>%
dm_add_fk(
disps, client_id,
clients
) %>%
dm_add_fk(
accounts,
district_id, districts
) %>%
dm_add_fk(
clients,
district_id, districts
) %>%
dm_add_fk(
cards, disp_id,
disps
) %>%
dm_rm_tbl(tkeys) %>%
dm_set_colors(orange = accounts)
}
my_dm <- financial_dm()
dm_draw(my_dm)
dm_squash_to_tbl(my_dm, loans)
my_dm %>%
dm_set_colors(darkblue = loans, darkgreen = c(accounts, districts)) %>%
dm_draw()
library(nycflights13)
flights_dm <-
dm(flights, planes) %>%
dm_add_pk(planes, tailnum) %>%
dm_add_fk(flights, tailnum, planes)
dm_draw(flights_dm)
sqlite <- dbConnect(RSQLite::SQLite(), dbname = ":memory:")
flights_dm_production <- copy_dm_to(sqlite, flights_dm)
flights_dm_production
|
test_that("basic run", {
testthat::skip_on_cran()
local_edition(3)
expect_error(run_MC_TL_DELOC(method = "error"), "Allowed keywords for 'method' are either 'par' or 'seq'!")
expect_error(run_MC_TL_DELOC(output = "error"), "Allowed keywords for 'output' are either 'signal' or 'remaining_e'!")
results_seq <- expect_silent(run_MC_TL_DELOC(
E = 0.5,
s = 1e8,
times = 0:100,
clusters = 1e1,
n_filled = 1,
R = 1e-7,
method = "seq"
))
results_par <- expect_silent(run_MC_TL_DELOC(
E = 0.5,
s = 1e8,
times = 0:100,
clusters = 1e1,
n_filled = 1,
R = 1e-7,
method = "par"
))
expect_silent(run_MC_TL_DELOC(
E = 0.5,
s = 1e8,
times = 0:100,
clusters = create_ClusterSystem(10),
n_filled = 100,
R = 1e-7,
method = "seq"
))
expect_s3_class(results_par, class = "RLumCarlo_Model_Output")
expect_length(results_par, 2)
expect_s3_class(results_seq, class = "RLumCarlo_Model_Output")
expect_length(results_seq, 2)
})
|
survexp.fit <- function(group, x, y, times, death, ratetable) {
if (!is.matrix(x)) stop("x must be a matrix")
if (ncol(x) != length(dim(ratetable)))
stop("x matrix does not match the rate table")
atts <- attributes(ratetable)
ngrp <- max(group)
times <- sort(unique(times))
if (any(times <0)) stop("Negative time point requested")
if (missing(y)) y <- rep(max(times), nrow(x))
ntime <- length(times)
if (!is.logical(death)) stop("Invalid value for death indicator")
datecheck <- function(x)
inherits(x, c("Date", "POSIXt", "date", "chron"))
cuts <- lapply(attr(ratetable, "cutpoints"), function(x)
if (!is.null(x) & datecheck(x)) ratetableDate(x) else x)
if (is.null(atts$type)) {
rfac <- atts$factor
us.special <- (rfac >1)
}
else {
rfac <- 1*(atts$type ==1)
us.special <- (atts$type==4)
}
if (any(us.special)) {
if (is.null(atts$dimid)) dimid <- names(atts$dimnames)
else dimid <- atts$dimid
cols <- match(c("age", "year"), dimid)
if (any(is.na(cols)))
stop("ratetable does not have expected shape")
bdate <- as.Date("1970-01-01") + (x[,cols[2]] - x[,cols[1]])
byear <- format(bdate, "%Y")
offset <- as.numeric(bdate - as.Date(paste0(byear, "-01-01")))
x[,cols[2]] <- x[,cols[2]] - offset
if (any(rfac >1)) {
temp <- which(us.special)
nyear <- length(cuts[[temp]])
nint <- rfac[temp]
cuts[[temp]] <- round(approx(nint*(1:nyear), cuts[[temp]],
nint:(nint*nyear))$y - .0001)
}
}
storage.mode(x) <- storage.mode(y) <- "double"
storage.mode(times) <- "double"
temp <- .Call(Cpyears3b,
as.integer(death),
as.integer(rfac),
as.integer(atts$dim),
as.double(unlist(cuts)),
ratetable,
as.integer(group),
x, y, times,
as.integer(ngrp))
if (ntime==1) list(surv=temp$surv, n=temp$n)
else if (ngrp >1)
list(surv=apply(matrix(temp$surv, ntime, ngrp),2,cumprod),
n= matrix(temp$n, ntime, ngrp))
else list(surv=cumprod(temp$surv), n=temp$n)
}
|
tmap.pal.info <- local({
br <- RColorBrewer::brewer.pal.info[, 1:2]
br$origin <- factor("brewer", levels = c("brewer", "viridis"))
vr <- data.frame(maxcolors = rep.int(0, 5), category = factor("seq", levels = c("div", "qual", "seq")), origin = factor("viridis", levels = c("brewer", "viridis")), row.names = c("viridis", "magma", "plasma", "inferno", "cividis"))
rbind(br, vr)
})
get_default_contrast <- function(type, m) {
if (type=="seq") {
default_contrast_seq(m)
} else {
default_contrast_div(m)
}
}
plot_tmap_pals <- function(type, origin, m, contrast=NULL, stretch=NULL, cex =.9, cex_line = .8, print.hex = FALSE, col.blind="normal") {
pal_info <- tmap.pal.info
pal_nm <- row.names(pal_info)[pal_info$category==type & pal_info$origin == origin]
pal_labels <- pal_nm
n <- length(pal_nm)
if (col.blind!="normal") {
cb <- pal_info[pal_nm, ]$colorblind
pal_labels[pal_labels %in% c("Dark2", "Paired", "Set2")] <- c("Dark2 (3)", "Paired (4)", "Set2 (3)")
} else {
cb <- rep(TRUE, n)
}
grid.newpage()
label_width <- convertWidth(stringWidth("Acbdefghijk"), "in", valueOnly = TRUE) * cex
lH <- convertHeight(unit(1, "lines"), "in", valueOnly=TRUE) * cex_line
vp <- viewport(layout = grid.layout(nrow = 2*n + 1, ncol=m+2,
widths = unit(c(label_width, rep(1, m), label_width/4), c("in", rep("null", m), "in")),
heights = unit(c(lH, rep(c(lH, .33*lH), length.out=2*n+1), 1), c(rep("in", 2*n), "null"))))
pushViewport(vp)
lapply(1L:m, function(j) {
pushViewport(viewport(layout.pos.row = 1, layout.pos.col = 1+j))
grid.text(j, gp=gpar(cex=cex))
popViewport()
})
lapply(1L:n, function(i) {
pushViewport(viewport(layout.pos.row = i*2, layout.pos.col = 1))
grid.text(pal_labels[i], x = .1, just = "left", gp=gpar(cex=cex, col=ifelse(cb[i], "
popViewport()
if (origin == "brewer") {
if (type=="qual") {
pal <- get_brewer_pal(pal_nm[i], n=m, stretch=stretch, plot=FALSE)
ids <- which(pal==pal[1])[-1]
} else {
pal <- get_brewer_pal(pal_nm[i], n=m, contrast=contrast, plot=FALSE)
ids <- numeric(0)
}
} else {
pal <- viridis(m, option = pal_nm[i], begin = contrast[1], end = contrast[2])
ids <- numeric(0)
}
if (col.blind != "normal") pal <- dichromat(pal, type=col.blind)
fontcol <- ifelse(is_light(pal), "black", "white")
fontwidth <- convertWidth(stringWidth("
fontsize <- min(cex, (1/fontwidth) / m)
lapply(1L:m, function(j) {
pushViewport(viewport(layout.pos.row = i*2, layout.pos.col = 1+j))
grid.rect(gp=gpar(fill=pal[j]))
if (print.hex) grid.text(pal[j], gp=gpar(cex=fontsize, col=fontcol[j]))
if (j %in% ids) {
grid.circle(x=0, y=.5, r=.25, gp=gpar(fill="white", lwd=1))
}
popViewport()
})
})
popViewport()
}
is_light <- function(col) {
colrgb <- col2rgb(col)
apply(colrgb * c(.299, .587, .114), MARGIN=2, sum) >= 128
}
palette_explorer <- function() {
if (!requireNamespace("shiny")) stop("shiny package needed for this function to work. Please install it.", call. = FALSE)
if (!requireNamespace("shinyjs")) stop("shinyjs package needed for this function to work. Please install it.", call. = FALSE)
shiny::shinyApp(ui = shiny::fluidPage(
shinyjs::useShinyjs(),
shiny::div(
style = "font-size:75%;line-height:20px",
shiny::fluidRow(
shiny::column(3,
shiny::br(),
shiny::br(),
shiny::br(),
shiny::h4("Brewer"),
shiny::sliderInput("m_seq", "Number of colors",
min = 3, max = 20, value = 7)),
shiny::column(3,
shiny::br(),
shiny::br(),
shiny::br(),
shiny::h4("Sequential"),
shiny::strong("Contrast range"),
shiny::checkboxInput("auto_seq", label = "Automatic", value = TRUE),
shiny::uiOutput("contrast_seq_slider")),
shiny::column(6,
shiny::plotOutput("plot_seq", height = "285px"),
shiny::uiOutput("code_seq"))
),
shiny::fluidRow(
shiny::column(3,
shiny::h4("Brewer"),
shiny::sliderInput("m_cat", "Number of colors",
min = 3, max = 20, value = 8)
),
shiny::column(3,
shiny::h4("Categorical"),
shiny::checkboxInput("stretch", "Stretch", value=TRUE)
),
shiny::column(6,
shiny::plotOutput("plot_cat", height = "131px"),
shiny::uiOutput("code_cat")
)
),
shiny::fluidRow(
shiny::column(3,
shiny::h4("Brewer"),
shiny::sliderInput("m_div", "Number of colors",
min = 3, max = 20, value = 9)
),
shiny::column(3,
shiny::h4("Diverging"),
shiny::strong("Contrast range"),
shiny::checkboxInput("auto_div", label = "Automatic", value = TRUE),
shiny::uiOutput("contrast_div_slider")
),
shiny::column(6,
shiny::plotOutput("plot_div", height = "147px"),
shiny::uiOutput("code_div")
)
),
shiny::fluidRow(
shiny::column(3,
shiny::h4("Viridis"),
shiny::sliderInput("m_vir", "Number of colors",
min = 3, max = 20, value = 20)),
shiny::column(3,
shiny::h4("Sequential"),
shiny::sliderInput("contrast_vir", "Contrast range",
min = 0, max = 1, value = c(0, 1), step = .01)),
shiny::column(6,
shiny::h4(),
shiny::plotOutput("plot_vir", height = "85px"),
shiny::uiOutput("code_vir"))
),
shiny::wellPanel(
shiny::fluidRow(
shiny::column(4,
shiny::h4("Options"),
shiny::checkboxInput("hex", "Print color values", value = FALSE)
),
shiny::column(4,
shiny::radioButtons("direct_tmap", "Code generator", choices = c("Direct code", "tmap layer function code"), selected = "Direct code", inline = FALSE)
),
shiny::column(4,
shiny::radioButtons("col_blind", "Color blindness simulator", choices = c("Normal" ="normal", "Deuteranopia" = "deutan", "Protanopia" = "protan", "Tritanopia" = "tritan"), selected = "normal", inline = FALSE)
)
))
)),
server = function(input, output) {
output$contrast_seq_slider <- shiny::renderUI({
rng <- get_default_contrast("seq", input$m_seq)
if (is.null(input$auto_seq) || input$auto_seq) {
shiny::isolate({
shiny::div(
style = "font-size:0;margin-top:-20px",
shiny::sliderInput("contrast_seq", "",
min = 0, max = 1, value = c(rng[1], rng[2]), step = .01)
)
})
} else {
shiny::isolate({
crng <- input$contrast_seq
shiny::div(
style = "font-size:0;margin-top:-20px",
shiny::sliderInput("contrast_seq", "",
min = 0, max = 1, value = c(crng[1], crng[2]), step = .01)
)
})
}
})
output$contrast_div_slider <- shiny::renderUI({
rng <- get_default_contrast("div", input$m_div)
if (is.null(input$auto_div) || input$auto_div) {
shiny::isolate({
shiny::div(
style = "font-size:0;margin-top:-20px",
shiny::sliderInput("contrast_div", "",
min = 0, max = 1, value = c(rng[1], rng[2]), step = .01)
)
})
} else {
shiny::isolate({
crng <- input$contrast_div
shiny::div(
style = "font-size:0;margin-top:-20px",
shiny::sliderInput("contrast_div", "",
min = 0, max = 1, value = c(crng[1], crng[2]), step = .01)
)
})
}
})
shiny::observe({
input$m_seq
if (input$auto_seq) {
shinyjs::delay(0, {
shinyjs::toggleState("contrast_seq", !input$auto_seq)
})
}
})
shiny::observe({
input$m_div
if (input$auto_div) {
shinyjs::delay(0, {
shinyjs::toggleState("contrast_div", !input$auto_div)
})
}
})
output$plot_seq <- shiny::renderPlot({
if (is.null(input$m_seq) || is.null(input$contrast_seq)) return(NULL)
plot_tmap_pals(type="seq", origin = "brewer", m = input$m_seq, contrast = input$contrast_seq, print.hex = input$hex, col.blind = input$col_blind)
})
output$plot_cat <- shiny::renderPlot({
if (is.null(input$m_cat) || is.null(input$stretch)) return(NULL)
plot_tmap_pals(type="qual", origin = "brewer", m = input$m_cat, stretch = input$stretch, print.hex = input$hex, col.blind = input$col_blind)
})
output$plot_div <- shiny::renderPlot({
if (is.null(input$m_div) || is.null(input$contrast_div)) return(NULL)
plot_tmap_pals(type="div", origin = "brewer", m = input$m_div, contrast = input$contrast_div, print.hex = input$hex, col.blind = input$col_blind)
})
output$plot_vir <- shiny::renderPlot({
if (is.null(input$m_vir) || is.null(input$contrast_vir)) return(NULL)
plot_tmap_pals(type="seq", origin = "viridis", m = input$m_vir, contrast = input$contrast_vir, print.hex = input$hex, col.blind = input$col_blind)
})
output$code_seq <- shiny::renderUI({
text <- get_palette_code(type="seq", origin = "brewer", m=input$m_seq, contrast=input$contrast_seq, auto=input$auto_seq, tmap=(input$direct_tmap == "tmap layer function code"))
shiny::div(
style = "font-family: Lucida Console,Lucida Sans Typewriter,monaco,Bitstream Vera Sans Mono,monospace;text-align:right;",
shiny::p(text)
)
})
output$code_div <- shiny::renderUI({
text <- get_palette_code(type="div", origin = "brewer", m=input$m_div, contrast=input$contrast_div, auto=input$auto_div, tmap=(input$direct_tmap == "tmap layer function code"))
shiny::div(
style = "font-family: Lucida Console,Lucida Sans Typewriter,monaco,Bitstream Vera Sans Mono,monospace;text-align:right;",
shiny::p(text)
)
})
output$code_cat <- shiny::renderUI({
text <- get_palette_code(type="cat", origin = "brewer", m=input$m_cat, auto=input$stretch, tmap= (input$direct_tmap == "tmap layer function code"))
shiny::div(
style = "font-family: Lucida Console,Lucida Sans Typewriter,monaco,Bitstream Vera Sans Mono,monospace;text-align:right;",
shiny::p(text)
)
})
output$code_vir <- shiny::renderUI({
text <- get_palette_code(type="seq", origin = "viridis", m=input$m_vir, contrast=input$contrast_vir, tmap= (input$direct_tmap == "tmap layer function code"))
shiny::div(
style = "font-family: Lucida Console,Lucida Sans Typewriter,monaco,Bitstream Vera Sans Mono,monospace;text-align:right;",
shiny::p(text)
)
})
}
)
}
tmap.pal.info <- local({
br <- RColorBrewer::brewer.pal.info
br$origin <- factor("brewer", levels = c("brewer", "viridis"))
vr <- data.frame(maxcolors = rep.int(Inf, 5), category = factor("seq", levels = c("div", "qual", "seq")), origin = factor("viridis", levels = c("brewer", "viridis")), colorblind = c(FALSE, FALSE, FALSE, FALSE, TRUE), row.names = c("viridis", "magma", "plasma", "inferno", "cividis"))
rbind(br, vr)
})
get_palette_code <- function(type, origin, m, contrast=NULL, auto=FALSE, tmap=FALSE) {
if (origin == "brewer") {
header <- ifelse(tmap, "tm_polygons(..., palette = ", "get_brewer_pal(")
pal <- ifelse(type=="seq", "\"Blues\"", ifelse(type=="cat", "\"Accent\"", "\"BrBG\""))
mtext <- paste(", n = ", m, sep="")
cntr <- ifelse(auto || is.null(contrast), "", paste(", contrast = c(", contrast[1], ", ", contrast[2], ")", sep = ""))
apm <- ifelse(type!="cat" || auto, "", ifelse(tmap, ", stretch.palette = FALSE", ", stretch = FALSE"))
tailer <- ifelse(tmap, ", ...)", ")")
paste(header, pal, mtext, cntr, apm, tailer, sep="")
} else {
header <- ifelse(tmap, "tm_polygons(..., palette = \"viridis\"", "viridisLite::viridis(")
mtext <- ifelse(tmap, paste(", n =", m), m)
cntr <- ifelse(is.null(contrast) || (contrast[1] == 0 && contrast[2] == 1), "",
ifelse(tmap,
paste(", contrast = c(", contrast[1], ", ", contrast[2], ")", sep = ""),
paste0(", begin = ", contrast[1], ", end = ", contrast[2])))
tailer <- ifelse(tmap, ", ...)", ")")
paste(header, mtext, cntr, tailer, sep="")
}
}
|
test_that("simpleTimeReport() works", {
expect_error(
expect_warning(
simpleTimeReport("title goes here", {
1 + 2
foo_warn <- function() warning("this is a warning")
foo_msg <- function() message("this is a message")
foo_warn()
foo_msg()
cat("this is a cat\n")
data.frame(a = 1, b = 2)
})
),
NA)
})
|
getUSCounty <- function(
longitude = NULL,
latitude = NULL,
dataset = 'USCensusCounties',
stateCodes = NULL,
allData = FALSE,
useBuffering = FALSE
) {
MazamaCoreUtils::stopIfNull(longitude)
MazamaCoreUtils::stopIfNull(latitude)
MazamaCoreUtils::stopIfNull(dataset)
MazamaCoreUtils::stopIfNull(allData)
MazamaCoreUtils::stopIfNull(useBuffering)
if ( !exists(dataset) ) {
stop("Missing dataset. Please loadSpatialData(\"", dataset, "\")",
call. = FALSE)
}
if ( min(longitude, na.rm = TRUE) < -180 ||
max(longitude, na.rm = TRUE) > 180) {
stop("'longitude' must be specified in the range -180:180.")
}
if ( min(latitude, na.rm = TRUE) < -90 ||
max(latitude, na.rm = TRUE) > 90 ) {
stop("'latitude' must be specified in the range -90:90.")
}
SPDF <- get(dataset)
if (!is.null(stateCodes)) SPDF <- SPDF[SPDF$stateCode %in% stateCodes,]
locationsDF <- getSpatialData(longitude, latitude, SPDF, useBuffering = useBuffering)
if (allData) {
return(locationsDF)
} else {
name <- locationsDF$countyName
return(name)
}
}
|
require(bigmemory)
a <- big.matrix(4, 4)
a[] <- 1:16
a[,]
b <- sub.big.matrix(a, firstCol = 2)
b[,]
c <- sub.big.matrix(b, firstRow = 2)
c[,]
d <- sub.big.matrix(c, lastCol = 1)
d[,]
|
ModelRecipe <- function(object, ...) {
UseMethod("ModelRecipe")
}
ModelRecipe.ModelRecipe <- function(object, ...) {
object
}
ModelRecipe.recipe <- function(object, ...) {
if (any(map("logi", function(step) isTRUE(step$trained), object$steps))) {
throw(Error("Recipe must be untrained."))
}
cases_name <- "(names)"
cases_fo <- ~ -`(names)`
reserved <- intersect(
c("(groups)", "(names)", "(strata)"), summary(object)$variable
)
if (length(reserved)) {
throw(Error(note_items(
"Supplied recipe contains reserved variable{?s}: ", reserved, "."
)))
}
cases_info <- data.frame(
variable = cases_name,
type = "nominal",
role = "case_name",
source = "original"
)
object$var_info <- rbind(object$var_info, cases_info)
object$term_info <- rbind(object$term_info, cases_info)
object$template[[cases_name]] <- rownames(object$template)
for (i in seq_along(object$steps)) {
step_terms <- object$steps[[i]]$terms
environment(cases_fo) <- environment(step_terms[[1]])
new_term <- rlang::as_quosure(cases_fo)
object$steps[[i]]$terms <- c(step_terms, new_term)
}
new("ModelRecipe", object)
}
bake.ModelRecipe <- function(object, new_data, ...) {
new_data <- if (is.null(new_data)) {
object$template
} else if (is(new_data, "ModelRecipe")) {
new_data$template
} else {
prep_recipe_data(new_data)
}
bake(as(object, "recipe"), new_data)
}
bake.SelectedInput <- function(object, ...) {
throw(Error("Cannot create a design matrix from a ", class(object), "."))
}
bake.TunedInput <- function(object, ...) {
throw(Error("Cannot create a design matrix from a ", class(object), "."))
}
prep.ModelFrame <- function(x, ...) x
prep.ModelRecipe <- function(x, ...) {
if (!is_trained(x)) {
template <- x$template
x <- new(class(x), prep(as(x, "recipe"), retain = FALSE))
x$template <- template
x$orig_lvls[["(names)"]] <- list(values = NA, ordered = NA)
x$levels[["(names)"]] <- x$orig_lvls[["(names)"]]
}
x
}
prep.SelectedInput <- function(x, ...) {
throw(Error("Cannot train a ", class(x), "."))
}
prep.TunedInput <- function(x, ...) {
throw(Error("Cannot train a ", class(x), "."))
}
prep_recipe_data <- function(x) {
if (is.null(x[["(names)"]])) x[["(names)"]] <- rownames(x)
x[c("(groups)", "(strata)")] <- NULL
x
}
recipe.ModelRecipe <- function(x, data, ...) {
stopifnot(is(data, "data.frame"))
x$template <- as_tibble(prep_recipe_data(data))
x
}
update.ModelRecipe <- function(object, params = list(), new_id = FALSE, ...) {
for (i in seq_along(object$steps)) {
step <- object$steps[[i]]
step_params <- params[[step$id]]
if (length(step_params)) {
object$steps[[i]] <- do.call(update, c(list(step), step_params))
}
}
if (new_id) object@id <- make_id()
object
}
|
AutoScore_rank <- function(train_set, ntree = 100) {
train_set$label <- as.factor(train_set$label)
model <-
randomForest::randomForest(label ~ .,
data = train_set,
ntree = ntree,
preProcess = "scale")
importance <- randomForest::importance(model, scale = F)
names(importance) <- rownames(importance)
importance <- sort(importance, decreasing = T)
cat("The ranking based on variable importance was shown below for each variable: \n")
print(importance)
return(importance)
}
AutoScore_parsimony <-
function(train_set,
validation_set,
rank,
max_score = 100,
n_min = 1,
n_max = 20,
cross_validation = FALSE,
fold = 10,
categorize = "quantile",
quantiles = c(0, 0.05, 0.2, 0.8, 0.95, 1),
max_cluster = 5,
do_trace = FALSE) {
if (n_max > length(rank)) {
warning(
"WARNING: the n_max (",
n_max,
") is larger the number of all variables (",
length(rank),
"). We Automatically revise the n_max to ",
length(rank)
)
n_max <- length(rank)
}
if (cross_validation == TRUE) {
index <- list()
all <- 1:length(train_set[, 1])
for (i in 1:(fold - 1)) {
a <- sample(all, trunc(length(train_set[, 1]) / fold))
index <- append(index, list(a))
all <- all[!(all %in% a)]
}
index <- c(index, list(all))
auc_set <- data.frame(rep(0, n_max - n_min + 1))
for (j in 1:fold) {
validation_set_temp <- train_set[index[[j]],]
train_set_tmp <- train_set[-index[[j]],]
AUC <- c()
for (i in n_min:n_max) {
variable_list <- names(rank)[1:i]
train_set_1 <- train_set_tmp[, c(variable_list, "label")]
validation_set_1 <-
validation_set_temp[, c(variable_list, "label")]
model_roc <-
compute_auc_val(
train_set_1,
validation_set_1,
variable_list,
categorize,
quantiles,
max_cluster,
max_score
)
AUC <- c(AUC, auc(model_roc))
}
names(AUC) <- n_min:n_max
if (do_trace) {
print(paste("list of AUC values for fold", j))
print(data.frame(AUC))
plot(
AUC,
main = paste("Parsimony plot (cross validation) for fold", j),
xlab = "Number of Variables",
ylab = "Area Under the Curve",
col = "
lwd = 2,
type = "o"
)
}
auc_set <- cbind(auc_set, data.frame(AUC))
}
auc_set$rep.0..n_max...n_min...1. <- NULL
auc_set$sum <- rowSums(auc_set) / fold
cat("***list of final mean AUC values through cross-validation are shown below \n")
print(data.frame(auc_set$sum))
plot(
auc_set$sum,
main = paste(
"Final Parsimony Plot based on ",
fold,
"-fold Cross Validation",
sep = ""
),
xlab = "Number of Variables",
ylab = "Area Under the Curve",
col = "
lwd = 2,
type = "o"
)
return(auc_set)
}
else{
AUC <- c()
for (i in n_min:n_max) {
cat(paste("Select", i, "Variable(s): "))
variable_list <- names(rank)[1:i]
train_set_1 <- train_set[, c(variable_list, "label")]
validation_set_1 <-
validation_set[, c(variable_list, "label")]
model_roc <-
compute_auc_val(
train_set_1,
validation_set_1,
variable_list,
categorize,
quantiles,
max_cluster,
max_score
)
print(auc(model_roc))
AUC <- c(AUC, auc(model_roc))
}
names(AUC) <- n_min:n_max
plot(
AUC,
main = "Parsimony Plot on the Validation Set",
xlab = "Number of Variables",
ylab = "Area Under the Curve",
col = "
lwd = 2,
type = "o"
)
return(AUC)
}
}
AutoScore_weighting <-
function(train_set,
validation_set,
final_variables,
max_score = 100,
categorize = "quantile",
max_cluster = 5,
quantiles = c(0, 0.05, 0.2, 0.8, 0.95, 1)) {
cat("****Included Variables: \n")
print(data.frame(variable_name = final_variables))
train_set_1 <- train_set[, c(final_variables, "label")]
validation_set_1 <-
validation_set[, c(final_variables, "label")]
cut_vec <-
get_cut_vec(
train_set_1,
categorize = categorize,
quantiles = quantiles,
max_cluster = max_cluster
)
train_set_2 <- transform_df_fixed(train_set_1, cut_vec)
validation_set_2 <-
transform_df_fixed(validation_set_1, cut_vec)
score_table <-
compute_score_table(train_set_2, max_score, final_variables)
cat("****Initial Scores: \n")
print_scoring_table(scoring_table = score_table, final_variable = final_variables)
validation_set_3 <- assign_score(validation_set_2, score_table)
validation_set_3$total_score <-
rowSums(subset(validation_set_3, select = names(validation_set_3)[names(validation_set_3) !=
"label"]))
y_validation <- validation_set_3$label
plot_roc_curve(validation_set_3$total_score, as.numeric(y_validation) - 1)
cat("***Performance (based on validation set):\n")
print_roc_performance(y_validation, validation_set_3$total_score, threshold = "best")
cat(
"***The cutoffs of each variable generated by the AutoScore are saved in cut_vec. You can decide whether to revise or fine-tune them \n"
)
return(cut_vec)
}
AutoScore_fine_tuning <-
function(train_set,
validation_set,
final_variables,
cut_vec,
max_score = 100) {
train_set_1 <- train_set[, c(final_variables, "label")]
validation_set_1 <-
validation_set[, c(final_variables, "label")]
train_set_2 <-
transform_df_fixed(train_set_1, cut_vec = cut_vec)
validation_set_2 <-
transform_df_fixed(validation_set_1, cut_vec = cut_vec)
score_table <-
compute_score_table(train_set_2, max_score, final_variables)
cat("***Fine-tuned Scores: \n")
print_scoring_table(scoring_table = score_table, final_variable = final_variables)
validation_set_3 <- assign_score(validation_set_2, score_table)
validation_set_3$total_score <-
rowSums(subset(validation_set_3, select = names(validation_set_3)[names(validation_set_3) !=
"label"]))
y_validation <- validation_set_3$label
plot_roc_curve(validation_set_3$total_score, as.numeric(y_validation) - 1)
cat("***Performance (based on validation set, after fine-tuning):\n")
print_roc_performance(y_validation, validation_set_3$total_score, threshold = "best")
return(score_table)
}
AutoScore_testing <-
function(test_set,
final_variables,
cut_vec,
scoring_table,
threshold = "best",
with_label = TRUE) {
if (with_label) {
test_set_1 <- test_set[, c(final_variables, "label")]
test_set_2 <-
transform_df_fixed(test_set_1, cut_vec = cut_vec)
test_set_3 <- assign_score(test_set_2, scoring_table)
test_set_3$total_score <-
rowSums(subset(test_set_3, select = names(test_set_3)[names(test_set_3) !=
"label"]))
test_set_3$total_score[which(is.na(test_set_3$total_score))] <-
0
y_test <- test_set_3$label
plot_roc_curve(test_set_3$total_score, as.numeric(y_test) - 1)
cat("***Performance using AutoScore (based on unseen test Set):\n")
model_roc <- roc(y_test, test_set_3$total_score, quiet = T)
print_roc_performance(y_test, test_set_3$total_score, threshold = threshold)
pred_score <-
data.frame(pred_score = test_set_3$total_score, Label = y_test)
return(pred_score)
} else {
test_set_1 <- test_set[, c(final_variables)]
test_set_2 <-
transform_df_fixed(test_set_1, cut_vec = cut_vec)
test_set_3 <- assign_score(test_set_2, scoring_table)
test_set_3$total_score <-
rowSums(subset(test_set_3, select = names(test_set_3)[names(test_set_3) !=
"label"]))
test_set_3$total_score[which(is.na(test_set_3$total_score))] <-
0
pred_score <-
data.frame(pred_score = test_set_3$total_score, Label = NA)
return(pred_score)
}
}
check_data <- function(data) {
if (is.null(data$label))
stop(
"ERROR: for this dataset: These is no dependent variable 'lable' to indicate the outcome. Please add one first\n"
)
if (length(levels(factor(data$label))) != 2)
warning("Please keep outcome lable variable binary\n")
non_num_fac <- c()
fac_large <- c()
special_case <- c()
for (i in names(data)) {
if ((class(data[[i]]) != "factor") &&
(class(data[[i]]) != "numeric"))
non_num_fac <- c(non_num_fac, i)
if ((length(levels(data[[i]])) > 10) &&
(class(data[[i]]) == "factor"))
fac_large <- c(fac_large, i)
if (grepl(",", i))
warning(
paste0(
"WARNING: the dataset has variable names '",
i,
"' with character ','. Please change it. Consider using '_' to replace\n"
)
)
if (grepl(")", i))
warning(
paste0(
"WARNING: the dataset has variable names '",
i,
"' with character ')'. Please change it. Consider using '_' to replace\n"
)
)
if (grepl("]", i))
warning(
paste0(
"WARNING: the dataset has variable names '",
i,
"' with character ']'. Please change it. Consider using '_' to replace\n"
)
)
if (class(data[[i]]) == "factor") {
if (sum(grepl(",", levels(data[[i]]))) > 0)
warning(
paste0(
"WARNING: the dataset has categorical variable '",
i,
"', where their levels contain ','. Please use 'levels(*your_variable*)' to change the name of the levels before using the AutoScore. Consider replacing ',' with '_'. Thanks! \n "
)
)
}
if (sum(grepl(i, names(data))) > 1) {
a <- names(data)[grepl(i, names(data))]
a <- a[a != i]
warning(
paste0(
"WARNING: the dataset has variable name '",
i,
"', which is entirely included by other variable names:\n",
paste(paste0("'", a, "'"), collapse = " "),
"\nPlease use 'names(*your_df*)' to change the name of variable '",
i,
"' before using the AutoScore. Consider adding '_1', '_2',..., '_x, or other similar stuff at end of that name, such as '",
paste0(i, "_1") ,
"', to make them totally different and not contain each other. Thanks!\n "
)
)
}
}
if (!is.null(non_num_fac))
warning(
paste(
"\nWARNING: the dataset has variable of character and user should transform them to factor before using AutoScore:\n",
non_num_fac
)
)
if (!is.null(fac_large))
warning(
paste(
"\nWARNING: The number of categories for some variables is too many :larger than: ",
fac_large
)
)
missing_rate <- colSums(is.na(data))
if (sum(missing_rate)) {
warning(
"\n WARNING: Your dataset contains NA. Please handle them before AutoScore. The variables with missing values are shown below:"
)
print(missing_rate[missing_rate != 0])
}
else
message("\n missing value check passed.\n")
}
split_data <- function(data, ratio, cross_validation = FALSE) {
if (cross_validation == FALSE) {
n <- length(data[, 1])
test_ratio <- ratio[3] / sum(ratio)
validation_ratio <- ratio[2] / sum(ratio)
test_index <- sample((1:n), test_ratio * n)
validate_index <-
sample((1:n)[!(1:n) %in% test_index], validation_ratio * n)
train_set <- data[-c(validate_index, test_index), ]
test_set <- data[test_index, ]
validation_set <- data[validate_index, ]
return(list(
train_set = train_set,
validation_set = validation_set,
test_set = test_set
))
}
else{
n <- length(data[, 1])
test_ratio <- ratio[3] / sum(ratio)
validation_ratio <- ratio[2] / sum(ratio)
test_index <- sample((1:n), test_ratio * n)
validate_index <-
sample((1:n)[!(1:n) %in% test_index], validation_ratio * n)
train_set <- data[-c(test_index),]
test_set <- data[test_index,]
validation_set <- train_set
return(list(
train_set = train_set,
validation_set = validation_set,
test_set = test_set
))
}
}
compute_descriptive_table <- function(df) {
descriptive_table <-
CreateTableOne(vars = names(df),
strata = "label",
data = df)
descriptive_table_overall <-
CreateTableOne(vars = names(df), data = df)
print(descriptive_table)
print(descriptive_table_overall)
}
compute_uni_variable_table <- function(df) {
uni_table <- data.frame()
for (i in names(df)[names(df) != "label"]) {
model <-
glm(
as.formula("label ~ ."),
data = subset(df, select = c("label", i)),
family = binomial,
na.action = na.omit
)
a <-
cbind(exp(cbind(OR = coef(model), confint.default(model))), summary(model)$coef[, "Pr(>|z|)"])
uni_table <- rbind(uni_table, a)
}
uni_table <-
uni_table[!grepl("Intercept", row.names(uni_table), ignore.case = T), ]
uni_table <- round(uni_table, digits = 3)
uni_table$V4[uni_table$V4 < 0.001] <- "<0.001"
uni_table$OR <-
paste(uni_table$OR,
"(",
uni_table$`2.5 %`,
"-",
uni_table$`97.5 %`,
")",
sep = "")
uni_table$`2.5 %` <- NULL
uni_table$`97.5 %` <- NULL
names(uni_table)[names(uni_table) == "V4"] <- "p value"
return(uni_table)
}
compute_multi_variable_table <- function(df) {
model <-
glm(label ~ .,
data = df,
family = binomial,
na.action = na.omit)
multi_table <-
cbind(exp(cbind(
adjusted_OR = coef(model), confint.default(model)
)), summary(model)$coef[, "Pr(>|z|)"])
multi_table <-
multi_table[!grepl("Intercept", row.names(multi_table), ignore.case = T), ]
multi_table <- round(multi_table, digits = 3)
multi_table <- as.data.frame(multi_table)
multi_table$V4[multi_table$V4 < 0.001] <- "<0.001"
multi_table$adjusted_OR <-
paste(
multi_table$adjusted_OR,
"(",
multi_table$`2.5 %`,
"-",
multi_table$`97.5 %`,
")",
sep = ""
)
multi_table$`2.5 %` <- NULL
multi_table$`97.5 %` <- NULL
names(multi_table)[names(multi_table) == "V4"] <- "p value"
return(multi_table)
}
print_scoring_table <- function(scoring_table, final_variable) {
table_tmp <- data.frame()
var_name <- names(scoring_table)
var_name_tmp<-gsub("\\(.*","",var_name)
var_name_tmp<-gsub("\\[.*","",var_name_tmp)
for (i in 1:length(final_variable)) {
var_tmp <- final_variable[i]
{
num <- grep(var_tmp, var_name_tmp)
if (grepl(",", var_name[num][1]) != TRUE) {
table_1 <-
data.frame(name = var_name[num], value = unname(scoring_table[num]))
table_1$rank_indicator <- c(seq(1:nrow(table_1)))
interval <-
c(gsub(
pattern = var_tmp,
replacement = "",
table_1$name
))
table_1$interval <- interval
table_2 <- table_1[order(table_1$interval),]
table_2$variable <- c(var_tmp, rep("", (nrow(table_2) - 1)))
table_3 <- rbind(table_2, rep("", ncol(table_2)))
table_tmp <- rbind(table_tmp, table_3)
}
else
{
num <- grep(paste("^",var_tmp,"$", sep=""), var_name_tmp)
table_1 <-
data.frame(name = var_name[num], value = unname(scoring_table[num]))
rank_indicator <- gsub(".*,", "", table_1$name)
rank_indicator <-
gsub(")", "", rank_indicator)
rank_indicator[which(rank_indicator == "")] <-
max(as.numeric(rank_indicator[-which(rank_indicator == "")])) + 1
rank_indicator <- as.numeric(rank_indicator)
{
if (length(rank_indicator) == 2) {
table_1$rank_indicator <- rank_indicator
table_2 <- table_1[order(table_1$rank_indicator),]
interval <- c(paste0("<", table_2$rank_indicator[1]))
interval <-
c(interval, paste0(">=", table_2$rank_indicator[length(rank_indicator) -
1]))
table_2$interval <- interval
table_2$variable <- c(var_tmp, rep("", (nrow(
table_2
) - 1)))
table_3 <- rbind(table_2, rep("", ncol(table_2)))
table_tmp <- rbind(table_tmp, table_3)
}
else{
table_1$rank_indicator <- rank_indicator
table_2 <- table_1[order(table_1$rank_indicator),]
interval <- c(paste0("<", table_2$rank_indicator[1]))
for (j in 1:(length(table_2$rank_indicator) - 2)) {
interval <-
c(
interval,
paste0(
"[",
table_2$rank_indicator[j],
",",
table_2$rank_indicator[j + 1],
")"
)
)
}
interval <-
c(interval, paste0(">=", table_2$rank_indicator[length(rank_indicator) -
1]))
table_2$interval <- interval
table_2$variable <- c(var_tmp, rep("", (nrow(
table_2
) - 1)))
table_3 <- rbind(table_2, rep("", ncol(table_2)))
table_tmp <- rbind(table_tmp, table_3)
}
}
}
}
}
table_tmp <- table_tmp[1:(nrow(table_tmp) - 1),]
table_final <-
data.frame(
variable = table_tmp$variable,
interval = table_tmp$interval,
point = table_tmp$value
)
table_kable_format <-
kable(table_final,
align = "llc",
caption = "AutoScore-created scoring model",
format = "rst")
print(table_kable_format)
invisible(table_final)
}
print_roc_performance <-
function(label, score, threshold = "best") {
if (sum(is.na(score)) > 0)
warning("NA in the score: ", sum(is.na(score)))
model_roc <- roc(label, score, quiet = T)
cat("AUC: ", round(auc(model_roc), 4), " ")
print(ci(model_roc))
if (threshold == "best") {
threshold <-
ceiling(coords(model_roc, "best", ret = "threshold", transpose = TRUE))
cat("Best score threshold: >=", threshold, "\n")
} else {
cat("Score threshold: >=", threshold, "\n")
}
cat("Other performance indicators based on this score threshold: \n")
roc <-
ci.coords(
model_roc,
threshold ,
ret = c("specificity", "sensitivity", "npv", "ppv"),
transpose = TRUE
)
cat(
"Sensitivity: ",
round(roc$sensitivity[2], 4),
" 95% CI: ",
round(roc$sensitivity[1], 4),
"-",
round(roc$sensitivity[3], 4),
"\n",
sep = ""
)
cat(
"Specificity: ",
round(roc$specificity[2], 4),
" 95% CI: ",
round(roc$specificity[1], 4),
"-",
round(roc$specificity[3], 4),
"\n",
sep = ""
)
cat(
"PPV: ",
round(roc$ppv[2], 4),
" 95% CI: ",
round(roc$ppv[1], 4),
"-",
round(roc$ppv[3], 4),
"\n",
sep = ""
)
cat(
"NPV: ",
round(roc$npv[2], 4),
" 95% CI: ",
round(roc$npv[1], 4),
"-",
round(roc$npv[3], 4),
"\n",
sep = ""
)
}
compute_score_table <-
function(train_set_2, max_score, variable_list) {
model <-
glm(label ~ ., family = binomial(link = "logit"), data = train_set_2)
coef_vec <- coef(model)
if (length(which(is.na(coef_vec))) > 0) {
warning(" WARNING: GLM output contains NULL, Replace NULL with 1")
coef_vec[which(is.na(coef_vec))] <- 1
}
train_set_2 <- change_reference(train_set_2, coef_vec)
model <-
glm(label ~ ., family = binomial(link = "logit"), data = train_set_2)
coef_vec <- coef(model)
if (length(which(is.na(coef_vec))) > 0) {
warning(" WARNING: GLM output contains NULL, Replace NULL with 1")
coef_vec[which(is.na(coef_vec))] <- 1
}
coef_vec_tmp <- round(coef_vec / min(coef_vec[-1]))
score_table <- add_baseline(train_set_2, coef_vec_tmp)
total_max <- max_score
total <- 0
for (i in 1:length(variable_list))
total <-
total + max(score_table[grepl(variable_list[i], names(score_table))])
score_table <- round(score_table / (total / total_max))
return(score_table)
}
compute_auc_val <-
function(train_set_1,
validation_set_1,
variable_list,
categorize,
quantiles,
max_cluster,
max_score) {
cut_vec <-
get_cut_vec(
train_set_1,
categorize = categorize,
quantiles = quantiles,
max_cluster = max_cluster
)
train_set_2 <- transform_df_fixed(train_set_1, cut_vec)
validation_set_2 <-
transform_df_fixed(validation_set_1, cut_vec)
if (sum(is.na(validation_set_2)) > 0)
warning("NA in the validation_set_2: ", sum(is.na(validation_set_2)))
if (sum(is.na(train_set_2)) > 0)
warning("NA in the train_set_2: ", sum(is.na(train_set_2)))
score_table <-
compute_score_table(train_set_2, max_score, variable_list)
if (sum(is.na(score_table)) > 0)
warning("NA in the score_table: ", sum(is.na(score_table)))
validation_set_3 <- assign_score(validation_set_2, score_table)
if (sum(is.na(validation_set_3)) > 0)
warning("NA in the validation_set_3: ", sum(is.na(validation_set_3)))
validation_set_3$total_score <-
rowSums(subset(validation_set_3, select = names(validation_set_3)[names(validation_set_3) !=
"label"]))
y_validation <- validation_set_3$label
model_roc <-
roc(y_validation, validation_set_3$total_score, quiet = T)
return(model_roc)
}
get_cut_vec <-
function(df,
quantiles = c(0, 0.05, 0.2, 0.8, 0.95, 1),
max_cluster = 5,
categorize = "quantile") {
cut_vec <- list()
for (i in 1:(length(df) - 1)) {
if (class(df[, i]) == "factor") {
if (length(levels(df[, i])) < 10)
(next)()
else
warning("WARNING: The number of categories should be less than 10",
names(df)[i])
}
if (categorize == "quantile") {
cut_off_tmp <- quantile(df[, i], quantiles)
cut_off_tmp <- unique(cut_off_tmp)
cut_off <- signif(cut_off_tmp, 3)
} else if (categorize == "k_means") {
clusters <- kmeans(df[, i], max_cluster)
cut_off_tmp <- c()
for (j in unique(clusters$cluster)) {
cut_off_tmp <-
append(cut_off_tmp, min(df[, i][clusters$cluster == j]))
}
cut_off_tmp <- append(cut_off_tmp, max(df[, i]))
cut_off_tmp <- sort(cut_off_tmp)
cut_off_tmp <- unique(cut_off_tmp)
cut_off <- signif(cut_off_tmp, 3)
cut_off <- unique(cut_off)
} else {
stop('ERROR: please specify correct method for categorizing: "quantile" or "k_means".')
}
l <- list(cut_off)
names(l)[1] <- names(df)[i]
cut_vec <- append(cut_vec, l)
}
for (i in 1:length(cut_vec)) {
if (length(cut_vec[[i]]) <= 2)
cut_vec[[i]] <- c("let_binary")
else
cut_vec[[i]] <- cut_vec[[i]][2:(length(cut_vec[[i]]) - 1)]
}
return(cut_vec)
}
transform_df_fixed <- function(df, cut_vec) {
j <- 1
for (i in 1:(length(df) - 1)) {
if (class(df[, i]) == "factor") {
if (length(levels(df[, i])) < 10)
(next)()
else
stop("ERROR: The number of categories should be less than 9")
}
vec <- df[, i]
cut_vec_new <- cut_vec[[j]]
if (cut_vec_new[1] == "let_binary") {
vec[vec != getmode(vec)] <- paste0("not_", getmode(vec))
vec <- as.factor(vec)
df[, i] <- vec
} else{
if (min(vec) < cut_vec[[j]][1])
cut_vec_new <- c(floor(min(df[, i])) - 100, cut_vec_new)
if (max(vec) >= cut_vec[[j]][length(cut_vec[[j]])])
cut_vec_new <- c(cut_vec_new, ceiling(max(df[, i]) + 100))
cut_vec_new_tmp <- signif(cut_vec_new, 3)
cut_vec_new_tmp <- unique(cut_vec_new_tmp)
df[, i] <-
cut(
df[, i],
breaks = cut_vec_new_tmp,
right = F,
include.lowest = F,
dig.lab = 3
)
if (min(vec) < cut_vec[[j]][1])
levels(df[, i])[1] <- gsub(".*,", "(,", levels(df[, i])[1])
if (max(vec) >= cut_vec[[j]][length(cut_vec[[j]])])
levels(df[, i])[length(levels(df[, i]))] <-
gsub(",.*", ",)", levels(df[, i])[length(levels(df[, i]))])
}
j <- j + 1
}
return(df)
}
plot_roc_curve <- function(prob, labels, quiet = TRUE) {
model_roc <- roc(labels, prob, quiet = quiet)
auc <- auc(model_roc)
roc.data <-
data.frame(fpr = as.vector(
coords(
model_roc,
"local maximas",
ret = "1-specificity",
transpose = TRUE
)
), tpr = as.vector(
coords(
model_roc,
"local maximas",
ret = "sensitivity",
transpose = TRUE
)
))
p <-
ggplot(roc.data, aes_string(x = "fpr", ymin = 0, ymax = "tpr")) + geom_ribbon(alpha = 0.2) + geom_line(aes_string(y = "tpr")) + xlab("1-Specificity") +
ylab("Sensitivity") + ggtitle(paste0(
"Receiver Operating Characteristic (ROC) Curve \nAUC=",
round(auc, digits = 4)
))
print(p)
}
change_reference <- function(df, coef_vec) {
df_tmp <- subset(df, select = names(df)[names(df) != "label"])
for (i in (1:length(df_tmp))) {
var_name <- names(df_tmp)[i]
var_levels <- levels(df_tmp[, i])
var_coef_names <- paste0(var_name, var_levels)
coef_i <- coef_vec[which(names(coef_vec) %in% var_coef_names)]
if (min(coef_i) < 0) {
ref <-
var_levels[which(var_coef_names == names(coef_i)[which.min(coef_i)])]
df_tmp[, i] <- relevel(df_tmp[, i], ref = ref)
}
}
df_tmp$label <- df$label
return(df_tmp)
}
add_baseline <- function(df, coef_vec) {
df <- subset(df, select = names(df)[names(df) != "label"])
coef_names_all <- unlist(lapply(names(df), function(var_name) {
paste0(var_name, levels(df[, var_name]))
}))
coef_vec_all <- numeric(length(coef_names_all))
names(coef_vec_all) <- coef_names_all
coef_vec_core <-
coef_vec[which(names(coef_vec) %in% names(coef_vec_all))]
i_coef <-
match(x = names(coef_vec_core),
table = names(coef_vec_all))
coef_vec_all[i_coef] <- coef_vec_core
coef_vec_all
}
assign_score <- function(df, score_table) {
for (i in 1:(length(names(df)) - 1)) {
score_table_tmp <-
score_table[grepl(names(df)[i], names(score_table))]
df[, i] <- as.character(df[, i])
for (j in 1:length(names(score_table_tmp))) {
df[, i][df[, i] %in% gsub(names(df)[i], "", names(score_table_tmp)[j])] <-
score_table_tmp[j]
}
df[, i] <- as.numeric(df[, i])
}
return(df)
}
getmode <- function(vect) {
uniqvect <- unique(vect)
uniqvect[which.max(tabulate(match(vect, uniqvect)))]
}
"sample_data"
"sample_data_small"
|
if(FALSE){
library(mvtnorm)
library(testthat)
library(BuyseTest)
library(data.table)
}
context("Check BuyseTest without strata")
n.patients <- c(90,100)
BuyseTest.options(check = TRUE,
keep.pairScore = TRUE,
method.inference = "none",
trace = 0)
set.seed(10)
dt.sim <- simBuyseTest(n.T = n.patients[1],
n.C = n.patients[2],
argsBin = list(p.T = list(c(0.5,0.5),c(0.25,0.75))),
argsCont = list(mu.T = 1:3, sigma.T = rep(1,3)),
argsTTE = list(scale.T = 1:3, scale.Censoring.T = rep(1,3)))
dt.sim$status1.noC <- 1
dtS.sim <- rbind(cbind(dt.sim, strata = 1),
cbind(dt.sim, strata = 2),
cbind(dt.sim, strata = 3))
test_that("BuyseTest - binary (no strata)", {
BT.bin <- BuyseTest(treatment ~ bin(toxicity1),
data = dt.sim)
BT2 <- BuyseTest(data = dt.sim,
endpoint = "toxicity1",
treatment = "treatment",
type = "bin")
test <- list(favorable = as.double(coef(BT.bin, statistic = "count.favorable", cumulative = FALSE)),
unfavorable = as.double(coef(BT.bin, statistic = "count.unfavorable", cumulative = FALSE)),
neutral = as.double(coef(BT.bin, statistic = "count.neutral", cumulative = FALSE)),
uninf = as.double(coef(BT.bin, statistic = "count.uninf", cumulative = FALSE)),
favorable = as.double(coef(BT.bin, statistic = "favorable", cumulative = TRUE)),
unfavorable = as.double(coef(BT.bin, statistic = "unfavorable", cumulative = TRUE)),
netChange = as.double(coef(BT.bin, statistic = "netBenefit", cumulative = TRUE)),
winRatio = as.double(coef(BT.bin, statistic = "winRatio", cumulative = TRUE))
)
GS <- list(favorable = c(1968) ,
unfavorable = c(2478) ,
neutral = c(4554) ,
uninf = c(0) ,
favorable = c(0.21866667) ,
unfavorable = c(0.27533333) ,
netChange = c(-0.05666667) ,
winRatio = c(0.79418886) )
expect_equal(test, GS, tol = 1e-6, scale = 1)
BT.bin@call <- list()
BT2@call <- list()
expect_equal(BT.bin,BT2)
tableS <- summary(BT.bin, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf])
)
})
test_that("BuyseTest - binary (strata)", {
BT.bin <- BuyseTest(treatment ~ bin(toxicity1) + strata,
data = dtS.sim)
tableS <- summary(BT.bin, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf]
))
expect_equal(dt.tableS[,total], c(27000,9000,9000,9000))
expect_equal(dt.tableS[,favorable], c(5904, 1968, 1968, 1968))
expect_equal(dt.tableS[,unfavorable], c(7434, 2478, 2478, 2478))
expect_equal(dt.tableS[,neutral], c(13662, 4554, 4554, 4554))
expect_equal(dt.tableS[,uninf], c(0, 0, 0, 0))
expect_equal(dt.tableS[,delta], c(-0.05666667, -0.05666667, -0.05666667, -0.05666667), tol = 1e-6)
expect_equal(dt.tableS[,Delta], c(-0.05666667, NA, NA, NA), tol = 1e-6)
})
test_that("BuyseTest - continuous (no strata)", {
BT.cont <- BuyseTest(treatment ~ cont(score1, 1) + cont(score2, 0),
data = dt.sim)
BT2 <- BuyseTest(data = dt.sim,
endpoint = c("score1","score2"),
treatment = "treatment",
type = c("cont","cont"),
threshold = c(1,0)
)
test <- list(favorable = as.double(coef(BT.cont, statistic = "count.favorable", cumulative = FALSE)),
unfavorable = as.double(coef(BT.cont, statistic = "count.unfavorable", cumulative = FALSE)),
neutral = as.double(coef(BT.cont, statistic = "count.neutral", cumulative = FALSE)),
uninf = as.double(coef(BT.cont, statistic = "count.uninf", cumulative = FALSE)),
favorable = as.double(coef(BT.cont, statistic = "favorable", cumulative = TRUE)),
unfavorable = as.double(coef(BT.cont, statistic = "unfavorable", cumulative = TRUE)),
netChange = as.double(coef(BT.cont, statistic = "netBenefit", cumulative = TRUE)),
winRatio = as.double(coef(BT.cont, statistic = "winRatio", cumulative = TRUE))
)
GS <- list(favorable = c(2196, 2142) ,
unfavorable = c(2501, 2161) ,
neutral = c(4303, 0) ,
uninf = c(0, 0) ,
favorable = c(0.244, 0.482) ,
unfavorable = c(0.27788889, 0.518) ,
netChange = c(-0.03388889, -0.036) ,
winRatio = c(0.87804878, 0.93050193) )
BT.cont@call <- list()
BT2@call <- list()
expect_equal(test, GS, tol = 1e-6, scale = 1)
expect_equal(BT.cont,BT2)
tableS <- summary(BT.cont, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[, favorable + unfavorable + neutral + uninf]
))
})
test_that("BuyseTest - continuous (strata)", {
BT.cont <- BuyseTest(treatment ~ cont(score1, 1) + cont(score2, 0) + strata,
data = dtS.sim)
tableS <- summary(BT.cont, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf]
))
expect_equal(dt.tableS[,total], c(27000, 9000, 9000, 9000, 12909, 4303, 4303, 4303))
expect_equal(dt.tableS[,favorable], c(6588, 2196, 2196, 2196, 6426, 2142, 2142, 2142))
expect_equal(dt.tableS[,unfavorable], c(7503, 2501, 2501, 2501, 6483, 2161, 2161, 2161))
expect_equal(dt.tableS[,neutral], c(12909, 4303, 4303, 4303, 0, 0, 0, 0))
expect_equal(dt.tableS[,uninf], c(0, 0, 0, 0, 0, 0, 0, 0))
expect_equal(dt.tableS[,delta], c(-0.03388889, -0.03388889, -0.03388889, -0.03388889, -0.00211111, -0.00211111, -0.00211111, -0.00211111), tol = 1e-6)
expect_equal(dt.tableS[,Delta], c(-0.03388889, NA, NA, NA, -0.036, NA, NA, NA), tol = 1e-6)
})
for(method in c("Gehan","Peron")){
test_that(paste0("BuyseTest - tte (same, ",method,", no strata)"),{
BT.tte <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 1) + tte(eventtime1, status1, threshold = 0.5) + tte(eventtime1, status1, threshold = 0.25),
data = dt.sim,
scoring.rule = method,
correction.uninf = FALSE
)
BT.1tte <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 0.25),
data = dt.sim,
scoring.rule = method,
correction.uninf = FALSE
)
BT2 <- BuyseTest(data = dt.sim,
endpoint = c("eventtime1","eventtime1","eventtime1"),
status = c("status1","status1","status1"),
treatment = "treatment",
type = c("tte","tte","tte"),
threshold = c(1,0.5,0.25),
scoring.rule = method,
correction.uninf = FALSE
)
BT.tte@call <- list()
BT2@call <- list()
expect_equal(BT.tte, BT2)
expect_equal(sum(coef(BT.tte, statistic = "count.favorable", cumulative = FALSE)),
as.double(coef(BT.1tte, statistic = "count.favorable", cumulative = FALSE)))
expect_equal(sum(coef(BT.tte, statistic = "count.unfavorable", cumulative = FALSE)),
as.double(coef(BT.1tte, statistic = "count.unfavorable", cumulative = FALSE)))
expect_equal(coef(BT.tte, statistic = "count.neutral", cumulative = FALSE)[3],
coef(BT.1tte, statistic = "count.neutral", cumulative = FALSE))
expect_equal(coef(BT.tte, statistic = "count.uninf", cumulative = FALSE)[3],
coef(BT.1tte, statistic = "count.uninf", cumulative = FALSE))
expect_equal(coef(BT.tte, statistic = "netBenefit", cumulative = TRUE)[3],
coef(BT.1tte, statistic = "netBenefit", cumulative = TRUE))
expect_equal(coef(BT.tte, statistic = "winRatio", cumulative = TRUE)[3],
coef(BT.1tte, statistic = "winRatio", cumulative = TRUE))
test <- list(favorable = as.double(coef(BT.tte, statistic = "count.favorable", cumulative = FALSE)),
unfavorable = as.double(coef(BT.tte, statistic = "count.unfavorable", cumulative = FALSE)),
neutral = as.double(coef(BT.tte, statistic = "count.neutral", cumulative = FALSE)),
uninf = as.double(coef(BT.tte, statistic = "count.uninf", cumulative = FALSE)),
favorable = as.double(coef(BT.tte, statistic = "favorable", cumulative = TRUE)),
unfavorable = as.double(coef(BT.tte, statistic = "unfavorable", cumulative = TRUE)),
netChange = as.double(coef(BT.tte, statistic = "netBenefit", cumulative = TRUE)),
winRatio = as.double(coef(BT.tte, statistic = "winRatio", cumulative = TRUE))
)
if(method == "Gehan"){
GS <- list(favorable = c(438, 719, 543) ,
unfavorable = c(325, 582, 500) ,
neutral = c(2284, 1569, 1084) ,
uninf = c(5953, 5367, 4809) ,
favorable = c(0.04866667, 0.12855556, 0.18888889) ,
unfavorable = c(0.03611111, 0.10077778, 0.15633333) ,
netChange = c(0.01255556, 0.02777778, 0.03255556) ,
winRatio = c(1.34769231, 1.27563396, 1.20824449) )
}else if(method == "Peron"){
GS <- list(favorable = c(1289.0425448, 1452.9970531, 682.33602169) ,
unfavorable = c(2044.84933459, 908.62963327, 578.82862552) ,
neutral = c(5666.10812061, 3304.48143424, 2043.31678703) ,
uninf = c(0, 0, 0) ,
favorable = c(0.14322695, 0.30467107, 0.38048618) ,
unfavorable = c(0.22720548, 0.32816433, 0.39247862) ,
netChange = c(-0.08397853, -0.02349326, -0.01199244) ,
winRatio = c(0.6303851, 0.92841006, 0.96944434) )
}
expect_equal(test, GS, tolerance = 1e-6, scale = 1)
tableS <- summary(BT.tte, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf]),
tolerance = 1e-1, scale = 1)
})
}
for(method in c("Gehan","Peron")){
test_that(paste0("BuyseTest - tte (different, ",method,", no strata)"),{
BT.tte <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 1) + tte(eventtime2, status2, threshold = 0.5) + tte(eventtime3, status3, threshold = 0.25),
data = dt.sim, scoring.rule = method,
correction.uninf = FALSE)
BT2 <- BuyseTest(data = dt.sim,
endpoint = c("eventtime1","eventtime2","eventtime3"),
status = c("status1","status2","status3"),
treatment = "treatment",
type = c("tte","tte","tte"),
threshold = c(1,0.5,0.25),
scoring.rule = method,
correction.uninf = FALSE
)
test <- list(favorable = as.double(coef(BT.tte, statistic = "count.favorable", cumulative = FALSE)),
unfavorable = as.double(coef(BT.tte, statistic = "count.unfavorable", cumulative = FALSE)),
neutral = as.double(coef(BT.tte, statistic = "count.neutral", cumulative = FALSE)),
uninf = as.double(coef(BT.tte, statistic = "count.uninf", cumulative = FALSE)),
favorable = as.double(coef(BT.tte, statistic = "favorable", cumulative = TRUE)),
unfavorable = as.double(coef(BT.tte, statistic = "unfavorable", cumulative = TRUE)),
netChange = as.double(coef(BT.tte, statistic = "netBenefit", cumulative = TRUE)),
winRatio = as.double(coef(BT.tte, statistic = "winRatio", cumulative = TRUE))
)
BT.tte@call <- list()
BT2@call <- list()
expect_equal(BT.tte, BT2)
if(method == "Gehan"){
GS <- list(favorable = c(438, 620, 794) ,
unfavorable = c(325, 561, 361) ,
neutral = c(2284, 339, 73) ,
uninf = c(5953, 6717, 5828) ,
favorable = c(0.04866667, 0.11755556, 0.20577778) ,
unfavorable = c(0.03611111, 0.09844444, 0.13855556) ,
netChange = c(0.01255556, 0.01911111, 0.06722222) ,
winRatio = c(1.34769231, 1.19413093, 1.48516439) )
}else if(method == "Peron"){
GS <- list(favorable = c(1289.0425448, 2318.38791489, 1231.91554493) ,
unfavorable = c(2044.84933459, 1529.8258322, 491.18260522) ,
neutral = c(5666.10812061, 867.93018367, 94.79622337) ,
uninf = c(0, 949.96418985, 0) ,
favorable = c(0.14322695, 0.40082561, 0.53770511) ,
unfavorable = c(0.22720548, 0.39718613, 0.45176197) ,
netChange = c(-0.08397853, 0.00363948, 0.08594314) ,
winRatio = c(0.6303851, 1.00916315, 1.19023986) )
}
tableS <- summary(BT.tte, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf]),
tolerance = 1e-1, scale = 1)
})
}
for(method in c("Gehan","Peron")){
test_that(paste0("BuyseTest - tte (same, ",method,", strata)"),{
BT.tte <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 1) + tte(eventtime1, status1, threshold = 0.5) + tte(eventtime1, status1, threshold = 0.25) + strata,
data = dtS.sim, scoring.rule = method)
test <- list(favorable = as.double(coef(BT.tte, statistic = "count.favorable", stratified = TRUE, cumulative = FALSE)),
unfavorable = as.double(coef(BT.tte, statistic = "count.unfavorable", stratified = TRUE, cumulative = FALSE)),
neutral = as.double(coef(BT.tte, statistic = "count.neutral", stratified = TRUE, cumulative = FALSE)),
uninf = as.double(coef(BT.tte, statistic = "count.uninf", stratified = TRUE, cumulative = FALSE)),
favorable = as.double(coef(BT.tte, statistic = "favorable", stratified = FALSE, cumulative = TRUE)),
unfavorable = as.double(coef(BT.tte, statistic = "unfavorable", stratified = FALSE, cumulative = TRUE)),
netChange = as.double(coef(BT.tte, statistic = "netBenefit", stratified = FALSE, cumulative = TRUE)),
winRatio = as.double(coef(BT.tte, statistic = "winRatio", stratified = FALSE, cumulative = TRUE))
)
if(method == "Gehan"){
GS <- list(favorable = c(438, 438, 438, 719, 719, 719, 543, 543, 543) ,
unfavorable = c(325, 325, 325, 582, 582, 582, 500, 500, 500) ,
neutral = c(2284, 2284, 2284, 1569, 1569, 1569, 1084, 1084, 1084) ,
uninf = c(5953, 5953, 5953, 5367, 5367, 5367, 4809, 4809, 4809) ,
favorable = c(0.04867, 0.12856, 0.18889) ,
unfavorable = c(0.03611, 0.10078, 0.15633) ,
netChange = c(0.01256, 0.02778, 0.03256) ,
winRatio = c(1.34769, 1.27563, 1.20824) )
} else if(method == "Peron"){
GS <- list(favorable = c(1289.04254, 1289.04254, 1289.04254, 1452.99705, 1452.99705, 1452.99705, 682.33602, 682.33602, 682.33602) ,
unfavorable = c(2044.84933, 2044.84933, 2044.84933, 908.62963, 908.62963, 908.62963, 578.82863, 578.82863, 578.82863) ,
neutral = c(5666.10812, 5666.10812, 5666.10812, 3304.48143, 3304.48143, 3304.48143, 2043.31679, 2043.31679, 2043.31679) ,
uninf = c(0, 0, 0, 0, 0, 0, 0, 0, 0) ,
favorable = c(0.14323, 0.30467, 0.38049) ,
unfavorable = c(0.22721, 0.32816, 0.39248) ,
netChange = c(-0.08398, -0.02349, -0.01199) ,
winRatio = c(0.63039, 0.92841, 0.96944) )
}
expect_equal(GS, test, tol = 1e-4, scale = 1)
tableS <- summary(BT.tte, print = FALSE, percentage = FALSE)$table
expect_equal(tableS[tableS$strata=="1","Delta"],tableS[tableS$strata=="2","Delta"])
expect_equal(tableS[tableS$strata=="1","Delta"],tableS[tableS$strata=="3","Delta"])
expect_equal(tableS[tableS$strata=="1","Delta"],tableS[tableS$strata=="3","Delta"])
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf]),
tolerance = 1e-1, scale = 1)
})
}
for(method in c("Gehan","Peron")){
test_that(paste0("BuyseTest - mixed (",method,", no strata)"),{
BT.mixed <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 0.5) + cont(score1, 1) + bin(toxicity1) + tte(eventtime1, status1, threshold = 0.25) + cont(score1, 0.5),
data = dt.sim, scoring.rule = method)
BT2 <- BuyseTest(data=dt.sim,
endpoint=c("eventtime1","score1","toxicity1","eventtime1","score1"),
status=c("status1","..NA..","..NA..","status1","..NA.."),
treatment="treatment",
type=c("timeToEvent","continuous","binary","timeToEvent","continuous"),
threshold=c(0.5,1,NA,0.25,0.5),
scoring.rule=method)
BT.mixed@call <- list()
BT2@call <- list()
expect_equal(BT.mixed, BT2)
test <- list(favorable = as.double(coef(BT.mixed, statistic = "count.favorable", cumulative = FALSE)),
unfavorable = as.double(coef(BT.mixed, statistic = "count.unfavorable", cumulative = FALSE)),
neutral = as.double(coef(BT.mixed, statistic = "count.neutral", cumulative = FALSE)),
uninf = as.double(coef(BT.mixed, statistic = "count.uninf", cumulative = FALSE)),
favorable = as.double(coef(BT.mixed, statistic = "favorable", cumulative = TRUE)),
unfavorable = as.double(coef(BT.mixed, statistic = "unfavorable", cumulative = TRUE)),
netChange = as.double(coef(BT.mixed, statistic = "netBenefit", cumulative = TRUE)),
winRatio = as.double(coef(BT.mixed, statistic = "winRatio", cumulative = TRUE))
)
if(method == "Gehan"){
GS <- list(favorable = c(1157, 1753, 751, 134, 373) ,
unfavorable = c(907, 1806, 949, 129, 323) ,
neutral = c(1569, 3377, 1677, 277, 718) ,
uninf = c(5367, 0, 0, 1137, 0) ,
favorable = c(0.12855556, 0.32333333, 0.40677778, 0.42166667, 0.46311111) ,
unfavorable = c(0.10077778, 0.30144444, 0.40688889, 0.42122222, 0.45711111) ,
netChange = c(0.02777778, 0.02188889, -0.00011111, 0.00044444, 0.006) ,
winRatio = c(1.27563396, 1.07261334, 0.99972693, 1.00105513, 1.01312591) )
}else if(method == "Peron"){
GS <- list(favorable = c(2742.0395979, 792.80301972, 403.03891763, 160.70305305, 134.38721963) ,
unfavorable = c(2953.47896786, 896.93725328, 407.50415506, 142.85049401, 122.54879121) ,
neutral = c(3304.48143424, 1614.74116124, 804.19808854, 500.64454148, 243.70853064) ,
uninf = c(0, 0, 0, 0, 0) ,
favorable = c(0.30467107, 0.39276029, 0.43754239, 0.45539829, 0.4703302) ,
unfavorable = c(0.32816433, 0.42782402, 0.47310226, 0.48897454, 0.50259107) ,
netChange = c(-0.02349326, -0.03506373, -0.03555987, -0.03357625, -0.03226087) ,
winRatio = c(0.92841006, 0.91804169, 0.92483682, 0.93133333, 0.93581089) )
}
expect_equal(test, GS, tolerance = 1e-6, scale = 1)
tableS <- summary(BT.mixed, print = FALSE, percentage = FALSE)$table
dt.tableS <- as.data.table(tableS)[strata == "global"]
expect_equal(dt.tableS[,total],
unname(dt.tableS[,favorable + unfavorable + neutral + uninf])
)
})
}
test_that("ordering does not matter", {
BT.mixed1 <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 0.25) + cont(score1, 1),
data = dt.sim, scoring.rule = method)
BT.mixed2 <- BuyseTest(treatment ~ tte(eventtime1, status1, threshold = 0.5) + tte(eventtime1, status1, threshold = 0.25) + cont(score1, 1),
data = dt.sim, scoring.rule = method)
expect_equal(coef(BT.mixed2, statistic = "netBenefit")[2:3], coef(BT.mixed1, statistic = "netBenefit"), tol = 1e-6)
expect_equal(coef(BT.mixed2, statistic = "winRatio")[2:3], coef(BT.mixed1, statistic = "winRatio"), tol = 1e-6)
})
test_that(paste0("BuyseTest - Peron scoring rule with 2 TTE, one without censoring"),{
BT.mixed <- BuyseTest(treatment ~ tte(eventtime2, status2, threshold = 0.5) + tte(eventtime1, status1.noC, threshold = 0),
data = dt.sim, scoring.rule = "Peron")
expect_equal(unname(attr([email protected],"method.score")), c("SurvPeron","continuous"))
BT.mixed <- BuyseTest(treatment ~ tte(eventtime1, status1.noC, threshold = 0) + tte(eventtime2, status2, threshold = 0.5),
data = dt.sim, scoring.rule = "Peron")
expect_equal(unname(attr([email protected],"method.score")), c("continuous","SurvPeron"))
})
test_that("BuyseTest - left vs. right censoring", {
BT.left <- BuyseTest(treatment ~ tte(eventtime1, status = status1, censoring = "left"),
data = dt.sim,
scoring.rule = "Gehan")
expect_equal(as.double(coef(BT.left)), 0.09488889, tol = 1e-6)
BT.left <- BuyseTest(treatment ~ tte(eventtime1, status = status1, censoring = "left"),
data = dt.sim,
scoring.rule = "Gehan",
correction.uninf = TRUE)
expect_equal(as.double(coef(BT.left)), 0.1768116, tol = 1e-6)
})
df.1 <- data.frame(mean = 0:1, sd = 1, treatment = c("C","T"))
df.2 <- data.frame(mean = 0:1, sd = c(2,0.5), treatment = c("C","T"))
df.3 <- rbind(df.1,df.2)
test_that("BuyseTest - uncorrelated gaussians", {
GS.1 <- 1 - pnorm(0, mean = 1, sd = sqrt(2))
BTG.1 <- BuyseTest(treatment ~ gaus(mean, sd),
data = df.1, method.inference = "none")
expect_equal(GS.1,as.double(coef(BTG.1, statistic = "favorable")),tol=1e-6)
GS.2 <- 1 - pnorm(0, mean = 1, sd = sqrt(4.25))
BTG.2 <- BuyseTest(treatment ~ gaus(mean = mean, std = sd),
data = df.2, method.inference = "none")
expect_equal(GS.2,as.double(coef(BTG.2, statistic = "favorable")),tol=1e-6)
GS.3 <- mean(c(GS.1, (1 - pnorm(0, mean = 1, sd = sqrt(5))), 1 - pnorm(0, mean = 1, sd = sqrt(1.25)), GS.2))
BTG.3 <- BuyseTest(treatment ~ gaus(mean = mean, std = sd),
data = df.3, method.inference = "none")
expect_equal(GS.3,as.double(coef(BTG.3, statistic = "favorable")),tol=1e-6)
})
complement <- function(rho, n) {
x <- rnorm(n)
y <- rnorm(n)
y.perp <- residuals(lm(x ~ y))
z <- rho * sd(y.perp) * y + sqrt(1 - rho^2) * sd(y) * y.perp
return(list(Y=as.double(y),X=as.double(z)))
}
df.1$iid <- complement(rho = 0.5, n = 10)
df.2$iid <- complement(rho = 0.5, n = 10)
df.3 <- rbind(df.1,df.2)
test_that("BuyseTest - correlated gaussians", {
GS.1 <- 1 - pnorm(0, mean = 1, sd = sqrt(1))
BTG.1 <- BuyseTest(treatment ~ gaus(mean, sd, iid),
data = df.1, method.inference = "none")
expect_equal(GS.1,as.double(coef(BTG.1, statistic = "favorable")),tol=1e-6)
GS.2 <- 1 - pnorm(0, mean = 1, sd = sqrt(3.25))
BTG.2 <- BuyseTest(treatment ~ gaus(mean = mean, std = sd, iid),
data = df.2, method.inference = "none")
expect_equal(GS.2,as.double(coef(BTG.2, statistic = "favorable")),tol=1e-6)
GS.3 <- mean(c(GS.1,
1 - pnorm(0, mean = 1, sd = sqrt(1.25-cor(df.1$iid[[1]],df.2$iid[[2]]))),
1 - pnorm(0, mean = 1, sd = sqrt(5-4*cor(df.1$iid[[2]],df.2$iid[[1]]))),
GS.2))
BTG.3 <- BuyseTest(treatment ~ gaus(mean = mean, std = sd, iid = iid),
data = df.3, method.inference = "none")
expect_equal(GS.3,as.double(coef(BTG.3, statistic = "favorable")),tol=1e-6)
})
|
mod1 <- mread('ex_mbr1', mbrlib())
mod2 <- mread('ex_mbr2', mbrlib())
mod3 <- mread('ex_mbr3', mbrlib())
test_that("example models are suitable for these tests", {
expect_equal(adm_cmt(mod1), c(1,2))
expect_equal(adm_cmt(mod2), 1)
expect_equal(adm_cmt(mod3), 1)
expect_equal(adm_0_cmt(mod1), 2)
expect_equal(adm_0_cmt(mod2), 1)
expect_null(adm_0_cmt(mod3))
})
test_that("detection of default administration compartment is good",{
expect_equal(get_data(adm_lines(mod1, amt = 100))[["cmt"]], adm_cmt(mod1))
expect_equal(get_data(adm_lines(mod2, amt = 100))[["cmt"]], adm_cmt(mod2))
expect_equal(get_data(adm_lines(mod3, amt = 100))[["cmt"]], adm_cmt(mod3))
})
test_that("explicit cmt works well",{
expect_equal(get_data(adm_lines(mod1, amt = 100, cmt = 1))[["cmt"]], 1)
expect_equal(get_data(adm_lines(mod1, amt = 100, cmt = c(3, -99)))[["cmt"]], c(-99, 3))
})
test_that("rate incrementation is ok",{
expect_equal(get_data(adm_lines(mod1, amt = 100))[c("cmt","rate")], tibble(cmt = c(1,2), rate = c(0, -2)))
expect_equal(get_data(adm_lines(mod2, amt = 100))[c("cmt","rate")], tibble(cmt = 1, rate = -2))
expect_null(get_data(adm_lines(mod3, amt = 100))[["rate"]])
})
test_that("rate incrementation is ok with explicit cmt",{
expect_equal(get_data(adm_lines(mod2, amt = 100, cmt = 3))[["rate"]], 0)
expect_equal(get_data(adm_lines(mod2, amt = 100, cmt = c(1, 3, -99)))[c("cmt","rate")], tibble(cmt = c(-99, 1, 3), rate = c(0, -2 , 0)))
})
test_that("rate incrementation is ok with explicit rate",{
expect_equal(get_data(adm_lines(mod2, amt = 100, cmt = 3, rate = 150))[["rate"]], 150)
expect_equal(get_data(adm_lines(mod2, amt = 100, cmt = c(1, 3, -99), rate = 150))[c("cmt","rate")], tibble(cmt = c(-99, 1, 3), rate = 150))
})
test_that("ID increment ok", {
expect_equal((mod3 %>% adm_lines(ID = 3, amt = 100) %>% get_data())$ID, 3)
expect_equal((mod3 %>% adm_lines(ID = 3, amt = 100) %>% obs_lines(time = 23, DV = 1.01) %>% get_data())$ID, c(3,3))
expect_equal((mod3 %>% adm_lines(ID = 3, amt = 100) %>% adm_lines(ID = 2, time = 1, amt = 1) %>% get_data())$ID, c(2,3))
expect_error(mod3 %>% adm_lines(ID = 1, amt = 100) %>% obs_lines(ID = 88))
})
test_that("realize addl works", {
expect_equal(
mod3 %>%
adm_lines(amt = 100, addl = 9, ii = 24, realize_addl = T) %>%
get_data() %>%
nrow(),
10
)
})
test_that("no NA in SS, ADDL, RATE or II",{
data1 <- mod1 %>%
adm_lines(time = 0, amt = 10000) %>%
adm_lines(time = 72, amt = 10000, addl = 2, ii = 24, realize_addl = TRUE) %>%
get_data()
expect_false(any(is.na(data1$addl)))
expect_false(any(is.na(data1$ii)))
data2 <- mod2 %>%
adm_lines(time = 0, amt = 10000, ss = 1, ii = 24) %>%
adm_lines(time = 72, amt = 10000) %>%
get_data()
expect_false(any(is.na(data2$ss)))
expect_false(any(is.na(data2$ii)))
data3 <- mod3 %>%
adm_lines(time = 0, amt = 100, rate = 20) %>%
adm_lines(time = 24, amt = 100) %>%
get_data()
expect_false(any(is.na(data3$rate)))
})
|
confMatrixMetrics <- function(predTest,depTest,cutoff=0.5,dyn.cutoff=FALSE,predVal=NULL,depVal=NULL){
checkDepVector(depTest)
cm<-dynConfMatrix(predTest,depTest,cutoff=cutoff,dyn.cutoff=dyn.cutoff,predVal=predVal,depVal=depVal)
ACC<-sum(diag(cm$confMatrix))/sum(cm$confMatrix)
TP = cm$confMatrix[2,2]
TN = cm$confMatrix[1,1]
FP = cm$confMatrix[1,2]
FN = cm$confMatrix[2,1]
TPR = TP/(TP+FN)
TNR = TN/(FP+TN)
FPR = FP/(TP+FN)
FNR = FN/(FP+TN)
if (TP+FN>0) REC = TP/(TP+FN) else REC=NA
if (TP+FP>0) PRE = TP/(TP+FP) else PRE=NA
if (is.na(PRE)==FALSE && is.na(REC)==FALSE) F1 = 2*PRE*REC/(PRE+REC) else F1 = NA
ans<-list(accuracy=ACC,truePositiveRate=TPR,trueNegativeRate=TNR,falsePostiveRate=FPR,falseNegativeRate=FPR,F1Score=F1,cutoff=cutoff)
ans
}
|
write_JAGS_model <- function(filename = "MixSIAR_model.txt", resid_err = TRUE, process_err = TRUE, mix, source){
if(!process_err && !resid_err){
stop(paste("Invalid error structure, must choose one of:
1. Residual * Process (resid_err=TRUE, process_err=TRUE)
2. Residual only (resid_err=TRUE, process_err=FALSE)
3. Process only (resid_err=FALSE, process_err=TRUE)",sep=""))
}
if(resid_err && !process_err){
err_model <- "Residual only"
err <- "resid"
}
if(process_err && !resid_err){
err_model <- "Process only (MixSIR, for N = 1)"
err <- "process"
}
if(resid_err && process_err){
err_model <- "Residual * Process"
err <- "mult"
}
if(mix$N==1 && err!="process"){
stop(paste("Invalid error structure. If N=1 mix data point,
must choose Process only error model (MixSIR).
Set resid_err=FALSE and process_err=TRUE.",sep=""))}
if(mix$n.fe==1 && mix$N==mix$FAC[[1]]$levels && err!="process"){
stop(paste("Invalid error structure. If fitting each individual
mix data point separately, must choose Process only error model (MixSIR).
Set resid_err=FALSE and process_err=TRUE.",sep=""))}
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
cat("
", file=filename, append=T)
cat(paste("
if(source$data_type=="raw" && is.na(source$by_factor)){
cat("
var rho[n.sources,n.iso,n.iso], src_cov[n.sources,n.iso,n.iso], src_var[n.sources,n.iso,n.iso], src_Sigma[n.sources,n.iso,n.iso], Sigma.ind[N,n.iso,n.iso], mix.cov[N,n.iso,n.iso];", file=filename, append=T)
}
if(source$data_type=="raw" && !is.na(source$by_factor)){
cat("
var rho[n.sources,source_factor_levels,n.iso,n.iso], src_cov[n.sources,source_factor_levels,n.iso,n.iso], src_var[n.sources,source_factor_levels,n.iso,n.iso], src_Sigma[n.sources,source_factor_levels,n.iso,n.iso], Sigma.ind[N,n.iso,n.iso], mix.cov[N,n.iso,n.iso];", file=filename, append=T)
}
cat("
model{", file=filename, append=T)
if(source$data_type=="raw" && !is.na(source$by_factor) && mix$n.iso > 1){
cat("
for(src in 1:n.sources){
for(f1 in 1:source_factor_levels){
for(iso in 1:n.iso){
src_mu[src,iso,f1] ~ dnorm(0,.001);
}
for(i in 2:n.iso){
for(j in 1:(i-1)){
src_tau[src,f1,i,j] <- 0;
src_tau[src,f1,j,i] <- 0;
}
}
for(i in 1:n.iso){
src_tau[src,f1,i,i] ~ dgamma(.001,.001);
}
for(i in 2:n.iso){
for(j in 1:(i-1)){
rho[src,f1,i,j] ~ dunif(-1,1);
rho[src,f1,j,i] <- rho[src,f1,i,j];
}
}
for(i in 1:n.iso){
rho[src,f1,i,i] <- 1;
}
src_var[src,f1,,] <- inverse(src_tau[src,f1,,]);
src_cov[src,f1,,] <- src_var[src,f1,,] %*% rho[src,f1,,] %*% src_var[src,f1,,];
src_Sigma[src,f1,,] <- inverse(src_cov[src,f1,,]);
for(r in 1:n.rep[src,f1]){
SOURCE_array[src,,f1,r] ~ dmnorm(src_mu[src,,f1],src_Sigma[src,f1,,]);
}
}
}
", file=filename, append=T)
}
if(source$data_type=="raw" && is.na(source$by_factor) && mix$n.iso > 1){
cat("
for(src in 1:n.sources){
for(iso in 1:n.iso){
src_mu[src,iso] ~ dnorm(0,.001);
}
for(i in 2:n.iso){
for(j in 1:(i-1)){
src_tau[src,i,j] <- 0;
src_tau[src,j,i] <- 0;
}
}
for(i in 1:n.iso){
src_tau[src,i,i] ~ dgamma(.001,.001);
}
for(i in 2:n.iso){
for(j in 1:(i-1)){
rho[src,i,j] ~ dunif(-1,1);
rho[src,j,i] <- rho[src,i,j];
}
}
for(i in 1:n.iso){
rho[src,i,i] <- 1;
}
src_var[src,,] <- inverse(src_tau[src,,]);
src_cov[src,,] <- src_var[src,,] %*% rho[src,,] %*% src_var[src,,];
src_Sigma[src,,] <- inverse(src_cov[src,,]);
for(r in 1:n.rep[src]){
SOURCE_array[src,,r] ~ dmnorm(src_mu[src,],src_Sigma[src,,]);
}
}
", file=filename, append=T)
}
if(source$data_type=="raw" && mix$n.iso == 1){
cat("
for(src in 1:n.sources){
for(iso in 1:n.iso){
src_mu[src,iso] ~ dnorm(0,.001);
src_tau[src,iso,iso] ~ dgamma(.001,.001);
rho[src,iso,iso] <- 1;
}
src_var[src,,] <- 1/src_tau[src,,];
src_cov[src,,] <- src_var[src,,] %*% rho[src,,] %*% src_var[src,,];
src_Sigma[src,,] <- 1/src_cov[src,,];
for(r in 1:n.rep[src]){
SOURCE_array[src,,r] ~ dnorm(src_mu[src,],src_Sigma[src,,]);
}
}
", file=filename, append=T)
}
if(source$data_type=="means" && is.na(source$by_factor)){
cat("
for(src in 1:n.sources){
for(iso in 1:n.iso){
src_mu[src,iso] ~ dnorm(MU_array[src,iso], n_array[src]/SIG2_array[src,iso]);
tmp.X[src,iso] ~ dchisqr(n_array[src]);
src_tau[src,iso] <- tmp.X[src,iso]/(SIG2_array[src,iso]*(n_array[src] - 1));
}
}
", file=filename, append=T)
}
if(source$data_type=="means" && !is.na(source$by_factor)){
cat("
for(src in 1:n.sources){
for(f1 in 1:source_factor_levels){
for(iso in 1:n.iso){
src_mu[src,iso,f1] ~ dnorm(MU_array[src,iso,f1], n_array[src,f1]/SIG2_array[src,iso,f1]);
tmp.X[src,iso,f1] ~ dchisqr(n_array[src,f1]);
src_tau[src,iso,f1] <- tmp.X[src,iso,f1]/(SIG2_array[src,iso,f1]*(n_array[src,f1] - 1));
}
}
}
", file=filename, append=T)
}
cat("
p.global[1:n.sources] ~ ddirch(alpha[1:n.sources]);
for(src in 1:(n.sources-1)){
gmean[src] <- prod(p.global[1:src])^(1/src);
ilr.global[src] <- sqrt(src/(src+1))*log(gmean[src]/p.global[src+1]);
}
", file=filename, append=T)
if(mix$n.effects > 0 && mix$FAC[[1]]$re){
cat("
fac1.sig ~ dunif(0,20);
fac1.invSig2 <- 1/(fac1.sig*fac1.sig);
for(f1 in 1:factor1_levels) {
for(src in 1:(n.sources-1)) {
ilr.fac1[f1,src] ~ dnorm(0,fac1.invSig2);
}
}
", file=filename, append=T)}
if(mix$n.effects > 0 && !mix$FAC[[1]]$re){
cat("
for(src in 1:(n.sources-1)){
ilr.fac1[1,src] <- 0;
for(f1 in 2:factor1_levels){
ilr.fac1[f1,src] ~ dnorm(0,1);
}
}
", file=filename, append=T)}
if(mix$n.effects > 1 && mix$FAC[[2]]$re){
cat("
fac2.sig ~ dunif(0,20);
fac2.invSig2 <- 1/(fac2.sig*fac2.sig);
for(f2 in 1:factor2_levels){
for(src in 1:(n.sources-1)){
ilr.fac2[f2,src] ~ dnorm(0,fac2.invSig2);
}
}
", file=filename, append=T)}
if(mix$n.effects > 1 && !mix$FAC[[2]]$re){
cat("
for(src in 1:(n.sources-1)){
ilr.fac2[1,src] <- 0;
for(f2 in 2:factor2_levels){
ilr.fac2[f2,src] ~ dnorm(0,1);
}
}
", file=filename, append=T)}
ilr.cont.string <- ""
if(mix$n.ce > 0){
cat("
for(ce in 1:mix$n.ce){
cat("
for(src in 1:(n.sources-1)){
ilr.cont",ce,"[src] ~ dnorm(0,.001)
}
", file=filename, append=T, sep="")
ilr.cont.string <- paste(ilr.cont.string," + ilr.cont",ce,"[src]*Cont.",ce,"[i]",sep="")}
}
cat("
for(i in 1:N) {
for(src in 1:(n.sources-1)) {
ilr.ind[i,src] <- 0;", file=filename, append=T)
if(mix$n.effects==2){
cat("
ilr.tot[i,src] <- ilr.global[src] + ilr.fac1[Factor.1[i],src] + ilr.fac2[Factor.2[i],src]",ilr.cont.string," + ilr.ind[i,src];
}
}
", file=filename, append=T, sep="")}
if(mix$n.effects==1){
cat("
ilr.tot[i,src] <- ilr.global[src] + ilr.fac1[Factor.1[i],src]",ilr.cont.string," + ilr.ind[i,src];
}
}
", file=filename, append=T, sep="")}
if(mix$n.effects==0){
cat("
ilr.tot[i,src] <- ilr.global[src]",ilr.cont.string," + ilr.ind[i,src];
}
}
", file=filename, append=T, sep="")}
cat("
for(i in 1:N){
for(j in 1:(n.sources-1)){
cross[i,,j] <- (e[,j]^ilr.tot[i,j])/sum(e[,j]^ilr.tot[i,j]);
}
for(src in 1:n.sources){
tmp.p[i,src] <- prod(cross[i,src,]);
}
for(src in 1:n.sources){
p.ind[i,src] <- tmp.p[i,src]/sum(tmp.p[i,]);
}
}
for(src in 1:n.sources) {
for(i in 1:N){
p2[i,src] <- p.ind[i,src]*p.ind[i,src];
}
}
", file=filename, append=T)
if(mix$n.effects > 0 & !mix$fere){
if(mix$fac_nested[1]){
cat("
for(f1 in 1:factor1_levels) {
for(src in 1:(n.sources-1)) {
ilr.fac1.tot[f1,src] <- ilr.global[src] + ilr.fac2[factor2_lookup[f1],src] + ilr.fac1[f1,src];
cross.fac1[f1,,src] <- (e[,src]^ilr.fac1.tot[f1,src])/sum(e[,src]^ilr.fac1.tot[f1,src]);
}
for(src in 1:n.sources) {
tmp.p.fac1[f1,src] <- prod(cross.fac1[f1,src,]);
}
for(src in 1:n.sources){
p.fac1[f1,src] <- tmp.p.fac1[f1,src]/sum(tmp.p.fac1[f1,]);
}
}
", file=filename, append=T)
} else {
cat("
for(f1 in 1:factor1_levels) {
for(src in 1:(n.sources-1)) {
ilr.fac1.tot[f1,src] <- ilr.global[src] + ilr.fac1[f1,src];
cross.fac1[f1,,src] <- (e[,src]^ilr.fac1.tot[f1,src])/sum(e[,src]^ilr.fac1.tot[f1,src]);
}
for(src in 1:n.sources) {
tmp.p.fac1[f1,src] <- prod(cross.fac1[f1,src,]);
}
for(src in 1:n.sources){
p.fac1[f1,src] <- tmp.p.fac1[f1,src]/sum(tmp.p.fac1[f1,]);
}
}
", file=filename, append=T)
}
}
if(mix$n.effects > 1 & !mix$fere){
if(mix$fac_nested[2]){
cat("
for(f2 in 1:factor2_levels){
for(src in 1:(n.sources-1)){
ilr.fac2.tot[f2,src] <- ilr.global[src] + ilr.fac1[factor1_lookup[f2],src] + ilr.fac2[f2,src];
cross.fac2[f2,,src] <- (e[,src]^ilr.fac2.tot[f2,src])/sum(e[,src]^ilr.fac2.tot[f2,src]);
}
for(src in 1:n.sources) {
tmp.p.fac2[f2,src] <- prod(cross.fac2[f2,src,]);
}
for(src in 1:n.sources){
p.fac2[f2,src] <- tmp.p.fac2[f2,src]/sum(tmp.p.fac2[f2,]);
}
}
", file=filename, append=T)
} else {
cat("
for(f2 in 1:factor2_levels){
for(src in 1:(n.sources-1)){
ilr.fac2.tot[f2,src] <- ilr.global[src] + ilr.fac2[f2,src];
cross.fac2[f2,,src] <- (e[,src]^ilr.fac2.tot[f2,src])/sum(e[,src]^ilr.fac2.tot[f2,src]);
}
for(src in 1:n.sources) {
tmp.p.fac2[f2,src] <- prod(cross.fac2[f2,src,]);
}
for(src in 1:n.sources){
p.fac2[f2,src] <- tmp.p.fac2[f2,src]/sum(tmp.p.fac2[f2,]);
}
}
", file=filename, append=T)
}
}
if(mix$fere){
if(mix$n.re==1){
cat("
for(f1 in 1:factor1_levels) {
for(src in 1:(n.sources-1)) {
ilr.fac1.tot[f1,src] <- ilr.global[src] + ilr.fac1[f1,src];
cross.fac1[f1,,src] <- (e[,src]^ilr.fac1.tot[f1,src])/sum(e[,src]^ilr.fac1.tot[f1,src]);
}
for(src in 1:n.sources) {
tmp.p.fac1[f1,src] <- prod(cross.fac1[f1,src,]);
}
for(src in 1:n.sources){
p.fac1[f1,src] <- tmp.p.fac1[f1,src]/sum(tmp.p.fac1[f1,]);
}
}
", file=filename, append=T)
}
}
cat("
for(iso in 1:n.iso) {
for(i in 1:N) {
", file=filename, append=T)
if(!is.na(source$by_factor) && source$conc_dep==T){
if(source$by_factor == 1){
cat("
mix.mu[iso,i] <- (inprod(src_mu[,iso,Factor.1[i]],(p.ind[i,]*conc[,iso])) + inprod(frac_mu[,iso],(p.ind[i,]*conc[,iso]))) / inprod(p.ind[i,],conc[,iso]);", file=filename, append=T)
} else {
cat("
mix.mu[iso,i] <- (inprod(src_mu[,iso,Factor.2[i]],(p.ind[i,]*conc[,iso])) + inprod(frac_mu[,iso],(p.ind[i,]*conc[,iso]))) / inprod(p.ind[i,],conc[,iso]);", file=filename, append=T)
}
} else if(!is.na(source$by_factor) && source$conc_dep==F){
if(source$by_factor == 1){
cat("
mix.mu[iso,i] <- inprod(src_mu[,iso,Factor.1[i]],p.ind[i,]) + inprod(frac_mu[,iso],p.ind[i,]);", file=filename, append=T)
} else {
cat("
mix.mu[iso,i] <- inprod(src_mu[,iso,Factor.2[i]],p.ind[i,]) + inprod(frac_mu[,iso],p.ind[i,]);", file=filename, append=T)
}
} else if(is.na(source$by_factor) && source$conc_dep==T){
cat("
mix.mu[iso,i] <- (inprod(src_mu[,iso],(p.ind[i,]*conc[,iso])) + inprod(frac_mu[,iso],(p.ind[i,]*conc[,iso]))) / inprod(p.ind[i,],conc[,iso]);", file=filename, append=T)
} else if(is.na(source$by_factor) && source$conc_dep==F){
cat("
mix.mu[iso,i] <- inprod(src_mu[,iso],p.ind[i,]) + inprod(frac_mu[,iso],p.ind[i,]);", file=filename, append=T)
}
cat("
}
}
", file=filename, append=T)
if(err=="mult"){
cat("
for(iso in 1:n.iso){
resid.prop[iso] ~ dunif(0,20);
}
", file=filename, append=T)
if(source$data_type=="means"){
cat("
for(iso in 1:n.iso) {
for(i in 1:N) {
", file=filename, append=T)
if(!is.na(source$by_factor)){
if(source$by_factor == 1){
cat("
process.var[iso,i] <- inprod(1/src_tau[,iso,Factor.1[i]],p2[i,]) + inprod(frac_sig2[,iso],p2[i,]);", file=filename, append=T)
} else {
cat("
process.var[iso,i] <- inprod(1/src_tau[,iso,Factor.2[i]],p2[i,]) + inprod(frac_sig2[,iso],p2[i,]);", file=filename, append=T)
}
} else {
cat("
process.var[iso,i] <- inprod(1/src_tau[,iso],p2[i,]) + inprod(frac_sig2[,iso],p2[i,]);", file=filename, append=T)
}
cat("
}
}
for(ind in 1:N){
for(i in 1:n.iso){
for(j in 1:n.iso){
Sigma.ind[ind,i,j] <- equals(i,j)/(process.var[i,ind]*resid.prop[i]);
}
}
}
for(i in 1:N) {
", file=filename, append=T)
if(mix$n.iso > 1){
cat("
X_iso[i,] ~ dmnorm(mix.mu[,i], Sigma.ind[i,,]);
loglik[i] <- logdensity.mnorm(X_iso[i,], mix.mu[,i], Sigma.ind[i,,]);", file=filename, append=T)
} else {
cat("
X_iso[i,] ~ dnorm(mix.mu[,i], Sigma.ind[i,,]);
loglik[i] <- logdensity.norm(X_iso[i,], mix.mu[,i], Sigma.ind[i,,]);", file=filename, append=T)
}
cat("
}
}
", file=filename, append=T)
}
if(source$data_type=="raw"){
cat("
for(i in 1:n.iso){
for(j in 1:n.iso){
resid.prop.mat[i,j] <- sqrt(resid.prop[i]*resid.prop[j]);
}
}
for(ind in 1:N){
for(i in 1:n.iso){
for(j in 1:n.iso){
", file=filename, append=T)
if(!is.na(source$by_factor)){
if(source$by_factor == 1){
cat("
mix.cov[ind,i,j] <- equals(i,j)*resid.prop[i]*(inprod(src_cov[,Factor.1[ind],i,j],p2[ind,]) + inprod(frac_sig2[,i],p2[ind,])) + (1-equals(i,j))*inprod(src_cov[,Factor.1[ind],i,j],p2[ind,])*resid.prop.mat[i,j];", file=filename, append=T)
} else {
cat("
mix.cov[ind,i,j] <- equals(i,j)*resid.prop[i]*(inprod(src_cov[,Factor.2[ind],i,j],p2[ind,]) + inprod(frac_sig2[,i],p2[ind,])) + (1-equals(i,j))*inprod(src_cov[,Factor.2[ind],i,j],p2[ind,])*resid.prop.mat[i,j];", file=filename, append=T)
}
} else {
cat("
mix.cov[ind,i,j] <- equals(i,j)*resid.prop[i]*(inprod(src_cov[,i,j],p2[ind,]) + inprod(frac_sig2[,i],p2[ind,])) + (1-equals(i,j))*inprod(src_cov[,i,j],p2[ind,])*resid.prop.mat[i,j];", file=filename, append=T)
}
cat("
}
}
Sigma.ind[ind,,] <- inverse(mix.cov[ind,,]);
}
for(i in 1:N){
", file=filename, append=T)
if(mix$n.iso > 1){
cat("
X_iso[i,] ~ dmnorm(mix.mu[,i], Sigma.ind[i,,]);
loglik[i] <- logdensity.mnorm(X_iso[i,], mix.mu[,i], Sigma.ind[i,,]);", file=filename, append=T)
} else {
cat("
X_iso[i,] ~ dnorm(mix.mu[,i], Sigma.ind[i,,]);
loglik[i] <- logdensity.norm(X_iso[i,], mix.mu[,i], Sigma.ind[i,,]);", file=filename, append=T)
}
cat("
}
}
", file=filename, append=T)
}
}
if(err=="resid" && mix$n.iso>1){
cat("
Sigma ~ dwish(I,n.iso+1);
for(i in 1:N) {
X_iso[i,] ~ dmnorm(mix.mu[,i], Sigma);
loglik[i] <- logdensity.mnorm(X_iso[i,], mix.mu[,i], Sigma);
}
}
", file=filename, append=T)
}
if(err=="resid" && mix$n.iso==1){
cat("
Sigma ~ dgamma(.001,.001);
for(i in 1:N) {
X_iso[i,] ~ dnorm(mix.mu[,i], Sigma);
loglik[i] <- logdensity.norm(X_iso[i,], mix.mu[,i], Sigma);
}
}
", file=filename, append=T)
}
if(err=="process"){
cat("
for(i in 1:N){
for(iso in 1:n.iso){
", file=filename, append=T)
if(source$data_type=="raw"){
cat("
process.var[iso,i] <- inprod(1/src_tau[,iso,iso],p2[i,]) + inprod(frac_sig2[,iso],p2[i,]);", file=filename, append=T)
} else {
cat("
process.var[iso,i] <- inprod(1/src_tau[,iso],p2[i,]) + inprod(frac_sig2[,iso],p2[i,]);", file=filename, append=T)
}
cat("
mix.prcsn[iso,i] <- 1/process.var[iso,i];
X_iso[i,iso] ~ dnorm(mix.mu[iso,i], mix.prcsn[iso,i]);
loglik_mat[i,iso] <- logdensity.norm(X_iso[i,iso], mix.mu[iso,i], mix.prcsn[iso,i]);
}
loglik[i] <- sum(loglik_mat[i,])
}
}
", file=filename, append=T)
}
}
|
expected <- eval(parse(text="FALSE"));
test(id=0, code={
argv <- eval(parse(text="list(structure(c(1, 1, 1, 1, 2, 3), .Dim = c(3L, 2L), .Dimnames = list(NULL, c(\"I\", \"a\")), foo = \"bar\", class = \"matrix\"), structure(c(1, 1, 1, 1, 2, 3), .Dim = c(3L, 2L), class = \"matrix\", foo = \"bar\", .Dimnames = list(NULL, c(\"I\", \"a\"))), TRUE, TRUE, FALSE, TRUE, FALSE)"));
.Internal(identical(argv[[1]], argv[[2]], argv[[3]], argv[[4]], argv[[5]], argv[[6]], argv[[7]]));
}, o=expected);
|
`mv.Csample.test` <-
function(X, g, score="identity", stand="outer", method = "approximation", n.simu = 1000, na.action=na.fail,...)
{
DNAME=paste(deparse(substitute(X)),"by",deparse(substitute(g)))
score <- match.arg(score,c("identity","sign","rank"))
stand <- match.arg(stand,c("inner","outer"))
method <- match.arg(method,c("approximation","permutation"))
if (length(g)!= dim(X)[1]) stop("'g' must have as many elements as 'X' rows")
DATA <- data.frame(g=g)
DATA$X <- as.matrix(X)
DATA<-na.action(DATA)
X <- DATA$X
g <- DATA$g
if(!all(sapply(X, is.numeric))) stop("'X' must be numeric")
p<-dim(X)[2]
if (p<2) stop("'X' must be at least bivariate")
n<-dim(X)[1]
if (!is.factor(g)) stop("'g' must be a factor")
n.g<-length(g)
if (n.g!= n) stop("'g' must have as many elements as 'X' rows")
if (nlevels(g)<2) stop("'g' must have at least two levels")
if (min(by(g,g,length))<2) stop("each level of 'g' must have at least two observations")
res1<-switch(score,
"identity"={
hot.csample(X,g,method=method,n.simu=n.simu)
}
,
"sign"={
switch(stand,
"outer" = {
CssTestOuter(X,g,method=method,n.simu=n.simu,...)
}
,
"inner" = {
CssTestInner(X,g,method=method,n.simu=n.simu,...)
}
)
}
,
"rank"={
switch(stand,
"outer" = {
CsrTestOuter(X,g,method=method,n.simu=n.simu,...)
}
,
"inner" = {
CsrTestInner(X,g,method=method,n.simu=n.simu,...)
}
)
}
)
NVAL<-paste("c(",paste(rep(0,p),collapse=","),")",sep="")
names(NVAL)<-"location difference between some groups"
ALTERNATIVE <- "two.sided"
res<-c(res1,list(data.name=DNAME,alternative=ALTERNATIVE,null.value=NVAL))
class(res) <- "htest"
return(res)
}
|
goldsectmin <- function(f, a, b, tol = 1e-3, m = 100) {
iter <- 0
phi <- (sqrt(5) - 1) / 2
a.star <- b - phi * abs(b - a)
b.star <- a + phi * abs(b - a)
while (abs(b - a) > tol) {
iter <- iter + 1
if (iter > m) {
warning("iterations maximum exceeded")
break
}
if(f(a.star) < f(b.star)) {
b <- b.star
b.star <- a.star
a.star <- b - phi * abs(b - a)
} else {
a <- a.star
a.star <- b.star
b.star <- a + phi * abs(b - a)
}
}
return((a + b) / 2)
}
goldsectmax <- function(f, a, b, tol = 1e-3, m = 100) {
iter <- 0
phi <- (sqrt(5) - 1) / 2
a.star <- b - phi * abs(b - a)
b.star <- a + phi * abs(b - a)
while (abs(b - a) > tol) {
iter <- iter + 1
if (iter > m) {
warning("iterations maximum exceeded")
break
}
if(f(a.star) > f(b.star)) {
b <- b.star
b.star <- a.star
a.star <- b - phi * abs(b - a)
} else {
a <- a.star
a.star <- b.star
b.star <- a + phi * abs(b - a)
}
}
return((a + b) / 2)
}
|
miss2NA <- function(GADSdat) {
UseMethod("miss2NA")
}
miss2NA.GADSdat <- function(GADSdat) {
check_GADSdat(GADSdat)
datL <- lapply(names(GADSdat$dat), function(nam) {
recodeVar(var = GADSdat$dat[, nam], labs = GADSdat$labels[GADSdat$labels$varName == nam, ])
})
dat <- as.data.frame(datL, stringsAsFactors = FALSE)
names(dat) <- names(GADSdat$dat)
dat
}
recodeVar <- function(var, labs){
mLabs <- labs[labs$miss == "miss", ]
mCodes <- na_omit(mLabs[, "value", drop = TRUE])
var[var %in% mCodes] <- NA
var
}
|
test_ZVD <- function(w, test, classMeans, mus, scaling, ztol){
if (scaling==TRUE){
mu = mus$mu
sig = mus$sig
} else{
mu = mus
}
test_labels = factor(test[,1])
test_obs = as.matrix(data.frame(test[,2:dim(test)[2]]))
N = length(test_labels)
K = length(levels(test_labels))
test_obs = test_obs - matrix(1, nrow =N, ncol=1) %*% t(mu)
if (scaling==TRUE){
test_obs = test_obs %*% diag(1/sig)
}
proj = t(w) %*% t(as.matrix(test_obs))
cent = t(w) %*% classMeans
dist = apply(X = t(proj), MARGIN=1,
FUN=function(y){
apply(X=cent, MARGIN=2, FUN= function(x){ norm(as.matrix( x - y, 'f')) } )
}
)
predicted_labels = max.col(-t(dist))
true_labels = test[,1]
misclassed= sum(abs(true_labels - predicted_labels) > 0) / N
l0 = apply(w, MARGIN=2, FUN= function(x){ sum(abs(x)>ztol)})
l1 = apply(w, MARGIN=2, FUN= function(x){sum(abs(x))})
results = list(stats=list(mc=misclassed, l0=l0, l1=l1), pred_labs = predicted_labels, dist=dist)
return(results)
}
|
source("ESEUR_config.r")
statics=read.csv(paste0(ESEUR_dir, "regression/melton-statics.csv.xz"), as.is=TRUE)
statics$num_accesses=statics$access*statics$size
cyc_mod=glm(cycle ~ size+I(size^2), data=statics)
summary(cyc_mod)
|
NULL
spark_context <- function(sc) {
sc$state$spark_context
}
java_context <- function(sc) {
sc$state$java_context
}
hive_context <- function(sc) {
UseMethod("hive_context")
}
spark_session <- function(sc) {
UseMethod("spark_session")
}
hive_context.spark_connection <- function(sc) {
sc$state$hive_context
}
spark_session.spark_connection <- function(sc) {
sc$state$hive_context
}
spark_connection <- function(x, ...) {
UseMethod("spark_connection")
}
spark_connection.default <- function(x, ...) {
stop("Unable to retrieve a spark_connection from object of class ",
paste(class(x), collapse = " "),
call. = FALSE
)
}
spark_connection.spark_connection <- function(x, ...) {
x
}
spark_connection.spark_jobj <- function(x, ...) {
x$connection
}
connection_config <- function(sc, prefix, not_prefix = list()) {
config <- sc$config
master <- sc$master
isLocal <- spark_master_is_local(master)
isApplicable <- unlist(lapply(
seq_along(config),
function(idx) {
config_name <- names(config)[[idx]]
(is.null(prefix) || identical(substring(config_name, 1, nchar(prefix)), prefix)) &&
all(unlist(
lapply(not_prefix, function(x) !identical(substring(config_name, 1, nchar(x)), x))
)) &&
!(grepl("\\.local$", config_name) && !isLocal) &&
!(grepl("\\.remote$", config_name) && isLocal) &&
!(is.character(config[[idx]]) && all(nchar(config[[idx]]) == 0))
}
))
configNames <- lapply(
names(config)[isApplicable],
function(configName) {
configName %>%
substr(nchar(prefix) + 1, nchar(configName)) %>%
sub("(\\.local$)|(\\.remote$)", "", ., perl = TRUE)
}
)
configValues <- config[isApplicable]
names(configValues) <- configNames
configValues
}
spark_log <- function(sc, n = 100, filter = NULL, ...) {
UseMethod("spark_log")
}
spark_log.default <- function(sc, n = 100, ...) {
stop("Invalid class passed to spark_log")
}
print.spark_log <- function(x, ...) {
cat(x, sep = "\n")
}
spark_web <- function(sc, ...) {
if (!identical(sc$state, NULL) && !identical(sc$state$spark_web, NULL)) {
sc$state$spark_web
} else {
sparkui_url <- spark_config_value(
sc$config, c("sparklyr.web.spark", "sparklyr.sparkui.url")
)
if (!is.null(sparkui_url)) {
structure(sprintf("%s/jobs/", sparkui_url), class = "spark_web_url")
} else {
UseMethod("spark_web")
}
}
}
spark_web.default <- function(sc, ...) {
url <- tryCatch(
{
invoke(spark_context(sc), "%>%", list("uiWebUrl"), list("get"))
},
error = function(e) {
default_url <- "http://localhost:4040"
warning(
"Unable to retrieve Spark UI URL through SparkContext, ",
sprintf("will boldly assume it's '%s'", default_url)
)
default_url
}
)
if (!identical(substr(url, nchar(url), nchar(url)), "/")) {
url <- paste0(url, "/")
}
structure(sprintf("%sjobs/", url), class = "spark_web_url")
}
print.spark_web_url <- function(x, ...) {
tryCatch(
{
browse_url(x)
},
error = NULL
)
}
get_spark_sql_catalog_implementation <- function(sc) {
if (spark_version(sc) < "2.0.0") {
stop(
"get_spark_sql_catalog_implementation is only supported for Spark 2.0.0+",
call. = FALSE
)
}
invoke(
hive_context(sc),
"%>%",
list("conf"),
list("get", "spark.sql.catalogImplementation")
)
}
initialize_connection <- function(sc) {
UseMethod("initialize_connection")
}
new_spark_connection <- function(scon, ..., class = character()) {
structure(
scon,
...,
class = c("spark_connection", class, "DBIConnection")
)
}
new_spark_shell_connection <- function(scon, ..., class = character()) {
new_spark_connection(
scon,
...,
class = c(class, "spark_shell_connection")
)
}
new_spark_gateway_connection <- function(scon, ..., class = character()) {
new_spark_shell_connection(
scon,
...,
class = c(class, "spark_gateway_connection")
)
}
new_livy_connection <- function(scon) {
new_spark_connection(
scon,
class = "livy_connection"
)
}
|
context("tuning homogeneous models")
dfile <- system.file("testdata","testdataH.rda", package = "xnet")
load(dfile)
lambdas <- c(0.01)
mod <- tskrr(Yh,Kh,lambda = lambdas)
test_that("input of tune is correctly processed",{
expect_error(tune(mod, lim = "a"),
"lim .* single series of numeric values")
expect_error(tune(mod, lim = numeric(0)),
"lim needs 2 numeric values")
expect_error(tune(mod, lim = list(c(0.01,1), c(1,2))),
"lim .* single series of numeric values")
expect_error(tune(mod, ngrid = list(12,12)),
"ngrid .* single series of numeric values")
expect_warning(tune(mod, onedim = FALSE),
"one-dimensional search .* homogeneous networks")
})
tuned <- tune(mod,
lim = list(c(0.001,1)),
ngrid = list(20),
exclusion = "both")
manlambdas <- create_grid(lim = c(0.001,1),
ngrid = 20)
tunedman <- tune(mod,
lambda = manlambdas,
exclusion = "both")
tunedirect <- tune(Yh, Kh,
lim = list(c(0.001,1)),
ngrid = list(20),
exclusion = "both")
test_that("Output of tuned model is correct", {
expect_identical(tuned,
tune(tuned,
lim = list(c(0.001,1)),
ngrid = list(20),
exclusion = "both"))
expect_identical(tuned,
tunedman)
expect_identical(get_loo_fun(tuned),
get_loo_fun(mod,
exclusion = "both"))
expect_identical(tuned@loss_function,
loss_mse)
expect_identical(get_grid(tuned),
list(k = manlambdas))
lossval <- get_loss_values(tuned)
expect_equal(dim(lossval), c(length(manlambdas),1))
testmod <- update(mod,manlambdas[15])
expect_equal(lossval[15,1],
loss(testmod, exclusion = "both"))
expect_equal(tuned,
tunedirect)
})
test_that("loss is calculated correctly",{
expect_equal(loss(tuned),loss_mse(response(tuned),
loo(tuned, exclusion = "both")))
expect_equal(loss(tuned, exclusion = "interaction", fun = loss_auc,
replaceby0 = TRUE),
loss_auc(response(tuned),
loo(tuned, replaceby0 = TRUE)))
})
test_that("get_loo_fun works correctly on tuned homogeneous models",{
expect_identical(get_loo_fun(tuned,
exclusion = "interaction",
replaceby0 = TRUE),
get_loo_fun(mod,
exclusion = "interaction",
replaceby0 = TRUE))
})
|
GroAgeExp <-
function(x, ...) UseMethod("GroAgeExp")
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.