Nothing
# Part of the statnet package, http://statnetproject.org
#
# This software is distributed under the GPL-3 license. It is free,
# open source, and has the attribution requirements (GPL Section 7) in
# http://statnetproject.org/attribution
#
# Copyright 2013 the statnet development team
######################################################################
########################################################################
# This file contains the testing suite for the "query" methods, i.e.:
# is.active
# is.adjacent.active
#########################################################################
require(networkDynamic)
require(testthat)
#-------------------- IS.ACTIVE TESTS ---------------------------------
# Notes:
# -these are meant to be exhaustive except where noted otherwise
# -the list named "spells" created below is helpful for checking
# that the tests are correctly written
# -for understanding the comments, let
# L=finite number lower than spell boundary,
# H=finite number higher than spell boundary,
# M=finite number within a spell boundary
#----------------------------------------------------------------------
# create a test network
anet <- network.initialize(100)
set.seed(10)
heads <- sample(100, 150, replace=TRUE)
set.seed(25)
tails <- sample(100, 150, replace=TRUE)
add.edges(anet, tails, heads)
anet.copy <- anet
cat("testing is.active ... ")
# proper behavior for bad inputs? (not exhaustive)
# -- bad network input
a1 = try(is.active(3, 3, 3), T) # properly handeled
# -- bad onset
a2 = try(is.active(anet, "a", 3), T) # properly handeled
a3 = try(is.active(anet, NULL, 3), T) # properly handeled
# -- bad terminus
a4 = try(is.active(anet, 3, "b"), T) # properly handeled
# -- bad edges
a5 = try(is.active(anet, 3, 10, e=224), T) # properly handeled
a6 = try(is.active(anet, 3, 10, e=-2), T) # properly handeled
a7 = try(is.active(anet, 3, 10, e=NULL), T) # properly handeled
# -- bad vertices
a8 = try(is.active(anet, 3, 10, v=224), T) # properly handeled
a9 = try(is.active(anet, 3, 10, v=-2), T) # properly handeled
# -- bad rule
a10 = try(is.active(anet, 3, 20, e=1, rule=10), T) # properly handeled by R
a11 = try(is.active(anet, 15, 25, e=5, rule=c("all", "any")), T) # properly handeled by R
# -- bad active.default
a12 = try(is.active(anet, 3, 10, e=1, active.default=4), T) # returns 4
# -- bad onset & terminus combo
a13 = try(is.active(anet, 10, 3, e=5), T) # properly handeled
# -- bad edges & vertices combo
a14 = try(is.active(anet, 3, 10, e=5, v=4), T) # properly handeled
# now, for completely valid input ...
activate.edges(anet, c(-Inf, -Inf, 10, 10, 10),
c( Inf, 20, Inf, 20, 10), e=2:6)
activate.edges(anet, 10, 20, e=7)
activate.edges(anet, 20, 30, e=7)
activate.edges(anet, 30, 30, e=7)
activate.edges(anet, 40, 50, e=7)
deactivate.edges(anet, e=8)
spells = lapply(lapply(anet$mel[1:8],"[[","atl"),"[[","active")
# point queries that should be TRUE
b1 = is.active(anet, at=4, e= 1) # for any & NULL
b2 = is.active(anet, at=3, e= 2) # for M & (-Inf, Inf)
b3 = is.active(anet, at=-Inf, e= 2) # for -Inf & (-Inf, Inf)
b4 = is.active(anet, at=Inf, e= 2) # for Inf & (-Inf, Inf)
b5 = is.active(anet, at=5, e=3) # for M & (-Inf, b)
b6 = is.active(anet, at=15, e=7) # for M & (-Inf, b)
b7 = is.active(anet, at=-Inf, e=3) # for -Inf & (-Inf, b)
b8 = is.active(anet, at=50, e=4) # for M & (a, Inf)
b9 = is.active(anet, at=45, e=7) # for M & (a, Inf)
b10 = is.active(anet, at=10, e=4) # for a & (a, Inf)
b11 = is.active(anet, at=20, e=7) # for a & (a, Inf)
b12 = is.active(anet, at=Inf, e=4) # for Inf & (a, Inf)
b13 = is.active(anet, at=15, e=4) # for M & (a, b)
b14 = is.active(anet, at=25, e=7) # for M & (a, b)
b15 = is.active(anet, at=10, e=4) # for a & (a, b)
b16 = is.active(anet, at=20, e=7) # for a & (a, b)
b17 = is.active(anet, at=10, e=6) # for a & (a, a)
b18 = is.active(anet, at=30, e=7) # for a & (a, a)
b.tests = paste("b", seq(1,18), sep="")
b.results= sapply(b.tests, function(x){eval(parse(text=x))})
if(any(!b.results)){
bad.tests = paste("b", which(!b.results), sep="", collapse=" ")
stop(paste("is.active is returning improper FALSE values in tests",
bad.tests))
}
# point queries that should be FALSE
c1 = is.active(anet, at=4, e=1,active.default=F) # for any & NULL
c2 = is.active(anet, at=3, e=8) # for 'never active' NULL spell
c3 = is.active(anet, at=25, e=3) # for H & (-Inf, b)
c4 = is.active(anet, at=55, e=7) # for H & (-Inf, b)
c5 = is.active(anet, at=20, e=3) # for b & (-Inf, b)
c6 = is.active(anet, at=50, e=7) # for b & (-Inf, b)
c7 = is.active(anet, at=Inf, e=3) # for Inf & (-Inf, b)
c8 = is.active(anet, at=5, e=4) # for L & (a, Inf)
c9 = is.active(anet, at=35, e=7) # for L & (a, Inf)
c10 = is.active(anet, at=-Inf, e=4) # for -Inf & (a, Inf)
c11 = is.active(anet, at=5, e=5) # for L & (a, b)
c12 = is.active(anet, at=5, e=7) # for L & (a, b)
c13 = is.active(anet, at=25, e=5) # for H & (a, b)
c14 = is.active(anet, at=55, e=7) # for H & (a, b)
c15 = is.active(anet, at=20, e=5) # for b & (a, b)
c16 = is.active(anet, at=50, e=7) # for b & (a, b)
c17 = is.active(anet, at=0, e=6) # for L & (a, a)
c.tests = paste("c", seq(1,17), sep="")
c.results= sapply(c.tests, function(x){eval(parse(text=x))})
if(any(c.results)){
bad.tests = paste("c", which(c.results), sep="", collapse=" ")
stop(paste("is.active is returning improper TRUE values in tests",
bad.tests))
}
# interval queries that should be TRUE using 'rule=all'
d1 = is.active(anet, 4, 5, e= 1, rule='all') # for any & NULL
d2 = is.active(anet, -Inf, Inf, e= 1, rule='all') # for any & NULL
d3 = is.active(anet, -Inf, Inf, e= 2, rule='all') # for (-Inf,Inf) & (-Inf, Inf)
d4 = is.active(anet, -Inf, -Inf, e= 2, rule='all') # for (-Inf,-Inf)& (-Inf, Inf)
d5 = is.active(anet, Inf, Inf, e= 2, rule='all') # for (Inf,Inf) & (-Inf, Inf)
d6 = is.active(anet, 0, Inf, e= 2, rule='all') # for (M,Inf) & (-Inf, Inf)
d7 = is.active(anet, -Inf, 0, e= 2, rule='all') # for (-Inf,M) & (-Inf, Inf)
d8 = is.active(anet, 0, 0, e= 2, rule='all') # for (M,M) & (-Inf, Inf)
d9 = is.active(anet, 0, 10, e= 2, rule='all') # for (M,M) & (-Inf, Inf)
d10 = is.active(anet, -Inf, -Inf, e=3, rule='all') # for (-Inf,-Inf)& (-Inf, b)
d11 = is.active(anet, -Inf, 20, e=3, rule='all') # for (-Inf,b) & (-Inf, b)
d12 = is.active(anet, -Inf, 0, e=3, rule='all') # for (-Inf,M) & (-Inf, b)
d13 = is.active(anet, -5, 0, e=3, rule='all') # for (M,M) & (-Inf, b)
d14 = is.active(anet, 0, 20, e=3, rule='all') # for (M,b) & (-Inf, b)
d15 = is.active(anet, Inf, Inf, e=4, rule='all') # for (Inf,Inf) & (a, Inf)
d16 = is.active(anet, 10, Inf, e=4, rule='all') # for (a,Inf) & (a, Inf)
d17 = is.active(anet, 30, Inf, e=4, rule='all') # for (M,Inf) & (a, Inf)
d18 = is.active(anet, 10, 30, e=4, rule='all') # for (a,M) & (a, Inf)
d19 = is.active(anet, 30, 40, e=4, rule='all') # for (M,M) & (a, Inf)
d20 = is.active(anet, 10, 20, e=5, rule='all') # for (a,b) & (a, b)
d21 = is.active(anet, 10, 15, e=5, rule='all') # for (a,M) & (a, b)
d22 = is.active(anet, 15, 20, e=5, rule='all') # for (M,b) & (a, b)
d23 = is.active(anet, 10, 10, e=6, rule='all') # for (a,a) & (a, a)
d.tests = paste("d", seq(1,23), sep="")
d.results= sapply(d.tests, function(x){eval(parse(text=x))})
if(any(!d.results)){
bad.tests = paste("d", which(!d.results), sep="", collapse=" ")
stop(paste("is.active is returning improper FALSE values in tests",
bad.tests))
}
# interval queries that should be TRUE using default 'rule=any'
e1 = is.active(anet, 4, 5, e= 1) # for any & NULL
e2 = is.active(anet, -Inf, Inf, e= 1) # for any & NULL
e3 = is.active(anet, -Inf, Inf, e= 2) # for (-Inf,Inf) & (-Inf, Inf)
e4 = is.active(anet, -Inf, -Inf, e=2) # for (-Inf,-Inf)& (-Inf, Inf)
e5 = is.active(anet, Inf, Inf, e= 2) # for (Inf,Inf) & (-Inf, Inf)
e6 = is.active(anet, 0, Inf, e= 2) # for (M,Inf) & (-Inf, Inf)
e7 = is.active(anet, -Inf, 0, e= 2) # for (-Inf,M) & (-Inf, Inf)
e8 = is.active(anet, 0, 10, e= 2) # for (M,M) & (-Inf, Inf)
e9 = is.active(anet, -Inf, -Inf, e=3) # for (-Inf,-Inf)& (-Inf, b)
e10 = is.active(anet, -Inf, 20, e=3) # for (-Inf,b) & (-Inf, b)
e11 = is.active(anet, -Inf, 10, e=3) # for (-Inf,M) & (-Inf, b)
e12 = is.active(anet, -Inf, 30, e=3) # for (-Inf,H) & (-Inf, b)
e13 = is.active(anet, 0, 20, e=3) # for (M,b) & (-Inf, b)
e14 = is.active(anet, 0, 10, e=3) # for (M,M) & (-Inf, b)
e15 = is.active(anet, 0, 30, e=3) # for (M,H) & (-Inf, b)
e16 = is.active(anet, Inf, Inf, e=4) # for (Inf,Inf) & (a, Inf)
e17 = is.active(anet, 10, Inf, e=4) # for (a,Inf) & (a, Inf)
e18 = is.active(anet, 20, Inf, e=4) # for (M,Inf) & (a, Inf)
e19 = is.active(anet, 0, Inf, e=4) # for (L,Inf) & (a, Inf)
e20 = is.active(anet, 10, 20, e=4) # for (a,M) & (a, Inf)
e21 = is.active(anet, 0, 20, e=4) # for (L,M) & (a, Inf)
e22 = is.active(anet, 20, 30, e=4) # for (M,M) & (a, Inf)
e23 = is.active(anet, -Inf, Inf, e=5) # for (-Inf, Inf) & (a, b)
e24 = is.active(anet, 0, Inf, e=5) # for (L, Inf) & (a, b)
e25 = is.active(anet, 10, Inf, e=5) # for (a, Inf) & (a, b)
e26 = is.active(anet, 15, Inf, e=5) # for (M, Inf) & (a, b)
e27 = is.active(anet, -Inf, 30, e=5) # for (-Inf, H) & (a, b)
e28 = is.active(anet, -Inf, 20, e=5) # for (-Inf, b) & (a, b)
e29 = is.active(anet, -Inf, 15, e=5) # for (-Inf, M) & (a, b)
e30 = is.active(anet, 10, 20, e=5) # for (a,b) & (a, b)
e31 = is.active(anet, 10, 30, e=5) # for (a,H) & (a, b)
e32 = is.active(anet, 10, 15, e=5) # for (a,M) & (a, b)
e33 = is.active(anet, 0, 20, e=5) # for (L,b) & (a, b)
e34 = is.active(anet, 15, 20, e=5) # for (M,b) & (a, b)
e35 = is.active(anet, 0, 30, e=5) # for (L,H) & (a, b)
e36 = is.active(anet, 0, 15, e=5) # for (L,M) & (a, b)
e37 = is.active(anet, 15, 30, e=5) # for (M,H) & (a, b)
e38 = is.active(anet, 15, 18, e=5) # for (M,M) & (a, b)
e39 = is.active(anet, -Inf, Inf, e=6) # for (-Inf,Inf) & (a, a)
e40 = is.active(anet, 0, Inf, e=6) # for (L,Inf) & (a, a)
e41 = is.active(anet, -Inf, 20, e=6) # for (-Inf,H) & (a, a)
e42 = is.active(anet, 10, 20, e=6) # for (a, H) & (a, a)
e43 = is.active(anet, 30, 35, e=7) # for (a, H) & (a, a)
e44 = is.active(anet, 10, 10, e=6) # for (a, a) & (a, a)
e45 = is.active(anet, 0, 20, e=6) # for (L,H) & (a, a)
e.tests = paste("e", seq(1,45), sep="")
e.results= sapply(e.tests, function(x){eval(parse(text=x))})
if(any(!e.results)){
bad.tests = paste("e", which(!e.results), sep="", collapse=" ")
stop(paste("is.active is returning improper FALSE values in tests",
bad.tests))
}
# interval queries that should be FALSE using 'rule=all'
f1 = is.active(anet, 4, 5, e= 1, rule='all', active.default=F) # for any & NULL
f2 = is.active(anet, -Inf, Inf, e= 1, rule='all', active.default=F) # for any & NULL
f3 = is.active(anet, 3, 5, e= 8, rule= 'all') # for 'never active' NULL spell
f4 = is.active(anet, -Inf, Inf, e= 8, rule= 'all') # for 'never active' NULL spell
f5 = is.active(anet, -Inf, Inf, e=3, rule='all') # for (-Inf,Inf) & (-Inf, b)
f6 = is.active(anet, -Inf, 30, e=3, rule='all') # for (-Inf,H) & (-Inf, b)
f7 = is.active(anet, 0, 30, e=3, rule='all') # for (M,H) & (-Inf, b)
f8 = is.active(anet, 30, 40, e=3, rule='all') # for (H,H) & (-Inf, b)
f9 = is.active(anet, -Inf, Inf, e=4, rule='all') # for (-Inf,Inf) & (a, Inf)
f10 = is.active(anet, 0, Inf, e=4, rule='all') # for (L,Inf) & (a, Inf)
f11 = is.active(anet, 0, 20, e=4, rule='all') # for (L,M) & (a, Inf)
f12 = is.active(anet, 0, 5, e=4, rule='all') # for (L,L) & (a, Inf)
f13 = is.active(anet, -Inf, Inf, e=5, rule='all') # for (-Inf,Inf) & (a, b)
f14 = is.active(anet, -Inf, 0, e=5, rule='all') # for (-Inf,L) & (a, b)
f15 = is.active(anet, -Inf, 10, e=5, rule='all') # for (-Inf,a) & (a, b)
f16 = is.active(anet, -Inf, 15, e=5, rule='all') # for (-Inf,M) & (a, b)
f17 = is.active(anet, -Inf, 20, e=5, rule='all') # for (-Inf,b) & (a, b)
f18 = is.active(anet, -Inf, 30, e=5, rule='all') # for (-Inf,H) & (a, b)
f19 = is.active(anet, 0, Inf, e=5, rule='all') # for (L,Inf) & (a, b)
f20 = is.active(anet, 10, Inf, e=5, rule='all') # for (a,Inf) & (a, b)
f21 = is.active(anet, 15, Inf, e=5, rule='all') # for (M,Inf) & (a, b)
f22 = is.active(anet, 20, Inf, e=5, rule='all') # for (b,Inf) & (a, b)
f23 = is.active(anet, 30, Inf, e=5, rule='all') # for (H,Inf) & (a, b)
f24 = is.active(anet, 10, 30, e=5, rule='all') # for (a,H) & (a, b)
f25 = is.active(anet, 0, 10, e=5, rule='all') # for (L,a) & (a, b)
f26 = is.active(anet, 0, 20, e=5, rule='all') # for (L,b) & (a, b)
f27 = is.active(anet, 20, 30, e=5, rule='all') # for (b,H) & (a, b)
f28 = is.active(anet, 0, 15, e=5, rule='all') # for (L,M) & (a, b)
f29 = is.active(anet, 15, 30, e=5, rule='all') # for (M,H) & (a, b)
f30 = is.active(anet, 0, 30, e=5, rule='all') # for (L,H) & (a, b)
f31 = is.active(anet, -5, 5, e=5, rule='all') # for (L,L) & (a, b)
f32 = is.active(anet, 30, 40, e=5, rule='all') # for (H,H) & (a, b)
f33 = is.active(anet, -Inf,Inf, e=6, rule='all') # for (-Inf,Inf) & (a, a)
f34 = is.active(anet, -Inf, 0, e=6, rule='all') # for (-Inf,L) & (a, a)
f35 = is.active(anet, -Inf, 10, e=6, rule='all') # for (-Inf,a) & (a, a)
f36 = is.active(anet, -Inf, 20, e=6, rule='all') # for (-Inf,H) & (a, a)
f37 = is.active(anet, 0, Inf, e=6, rule='all') # for (L,Inf) & (a, a)
f38 = is.active(anet, 30, Inf, e=6, rule='all') # for (H,Inf) & (a, a)
f39 = is.active(anet, 0, 10, e=6, rule='all') # for (L,a) & (a, a)
f40 = is.active(anet, 10, 20, e=6, rule='all') # for (a,H) & (a, a)
f41 = is.active(anet, 30, 35, e=7, rule='all') # for (a,H) & (a, a)
f42 = is.active(anet, -5, 0, e=6, rule='all') # for (L,L) & (a, a)
f43 = is.active(anet, 0, 40, e=6, rule='all') # for (L,H) & (a, a)
f44 = is.active(anet, 30, 40, e=6, rule='all') # for (H,H) & (a, a)
f.tests = paste("f", seq(1,43), sep="")
f.results= sapply(f.tests, function(x){eval(parse(text=x))})
if(any(f.results)){
bad.tests = paste("f", which(f.results), sep="", collapse=" ")
stop(paste("is.active is returning improper TRUE values in tests",
bad.tests))
}
# interval queries that should be FALSE using default 'rule=any'
g1 = is.active(anet, 4, 5, e= 1, active.default=F) # for any & NULL
g2 = is.active(anet, -Inf, Inf, e= 1, active.default=F) # for any & NULL
g3 = is.active(anet, 3, 5, e= 8) # for 'never active' NULL spell
g4 = is.active(anet, -Inf, Inf, e= 8) # for 'never active' NULL spell
g5 = is.active(anet, Inf, Inf, e=3) # for (Inf, Inf) & (-Inf, b)
g6 = is.active(anet, 30, Inf, e=3) # for (H, Inf) & (-Inf, b)
g7 = is.active(anet, 20, 30, e=3) # for (b, H) & (-Inf, b)
g8 = is.active(anet, 30, 40, e=3) # for (H, H) & (-Inf, b)
g9 = is.active(anet, -Inf, -Inf, e=4) # for (-Inf,-Inf) & (a, Inf)
g10 = is.active(anet, -Inf, 0, e=4) # for (-Inf,L) & (a, Inf)
g11 = is.active(anet, 0, 10, e=4) # for (L, a) & (a, Inf)
g12 = is.active(anet, 0, 5, e=4) # for (L, L) & (a, Inf)
g13 = is.active(anet, -Inf, -Inf, e=5) # for (-Inf,-Inf) & (a, b)
g14 = is.active(anet, Inf, Inf, e=5) # for (Inf, Inf) & (a, b)
g15 = is.active(anet, -Inf, 0, e=5) # for (-Inf, L) & (a, b)
g16 = is.active(anet, 30, Inf, e=5) # for (H, Inf) & (a, b)
g17 = is.active(anet, -5, 10, e=5) # for (L,a) & (a, b)
g18 = is.active(anet, 20, 30, e=5) # for (b,H) & (a, b)
g19 = is.active(anet, -5, 5, e=5) # for (L,L) & (a, b)
g20 = is.active(anet, 30, 40, e=5) # for (H,H) & (a, b)
g21 = is.active(anet, -Inf,-Inf, e=6) # for (-Inf,-Inf) & (a, a)
g22 = is.active(anet, -Inf, 0, e=6) # for (-Inf,L) & (a, a)
g23 = is.active(anet, -Inf, 10, e=6) # for (-Inf,a) & (a, a)
g24 = is.active(anet, 30, Inf, e=6) # for (H,Inf) & (a, a)
g25 = is.active(anet, 0, 10, e=6) # for (L,a) & (a, a)
g26 = is.active(anet, -5, 0, e=6) # for (L1,L2) & (a, a)
g27 = is.active(anet, 30, 40, e=6) # for (H1,H2) & (a, a)
g.tests = paste("g", seq(1,27), sep="")
g.results= sapply(g.tests, function(x){eval(parse(text=x))})
if(any(g.results)){
bad.tests = paste("g", which(g.results), sep="", collapse=" ")
stop(paste("is.active is returning improper TRUE values in tests",
bad.tests))
}
expect_equal(is.active(network.initialize(0),at=1),logical(0))
# check for warning when eid specified for deleted edge
test<-network.initialize(3)
add.edges(test,1:3,c(2,3,1))
delete.edges(test,eid=2)
expect_warning(is.active(test,e=1:3,onset=-Inf,terminus=Inf),'correspond to deleted edges')
expect_equal(suppressWarnings(is.active(test,e=1:3,onset=-Inf,terminus=Inf)),c(TRUE,TRUE))
# check that 'earliest' and 'latest' rules accepted as equivilent to 'any' #544
test<-network.initialize(1)
activate.vertices(test,at=1)
expect_true(is.active(test,onset=0,terminus=2,rule='earliest',v=1))
expect_true(is.active(test,onset=0,terminus=2,rule='latest',v=1))
cat("ok\n")
#----------------- IS.ADJACENT.ACTIVE TESTS-----------------------------
# Notes:
# --this function is very brief, only really calling functions that
# are well tested (get.edgeIDs by time, is.active by me), thus
# the testing here is quite minimal
#-------------------------------------------------------------------
cat("testing is.adjacent.active ... ")
iov = as.matrix(anet, matrix.type="edgelist")[1:8,]
# tests that should return true for point queries
b1 = is.adjacent.active(anet, iov[2,1], iov[2,2], at=-Inf) # at -Inf
b2 = is.adjacent.active(anet, iov[3,1], iov[3,2], at=-Inf) # at -Inf
b3 = is.adjacent.active(anet, iov[2,1], iov[2,2], at=Inf) # at Inf
b4 = is.adjacent.active(anet, iov[4,1], iov[4,2], at=Inf) # at Inf
b5 = is.adjacent.active(anet, iov[4,1], iov[4,2], at=10) # at a
b6 = is.adjacent.active(anet, iov[7,1], iov[7,2], at=10) # at a
b7 = is.adjacent.active(anet, iov[7,1], iov[7,2], at=30) # at a
b8 = is.adjacent.active(anet, iov[7,1], iov[7,2], at=30) # at b
b9 = is.adjacent.active(anet, iov[7,1], iov[7,2], at=25) # at M
b10 = is.adjacent.active(anet, iov[3,1], iov[3,2], at=10) # at M
b11 = is.adjacent.active(anet, iov[4,1], iov[4,2], at=25) # at M
b12 = is.adjacent.active(anet, iov[1,1], iov[1,2], at=25) # at M
# tests that should return false for point queries b/c of non-adjacency
b13 = !is.adjacent.active(anet, iov[2,2], iov[2,1], at=-Inf) # at -Inf
b14 = !is.adjacent.active(anet, iov[3,2], iov[3,1], at=-Inf) # at -Inf
b15 = !is.adjacent.active(anet, iov[2,2], iov[2,1], at=Inf) # at Inf
c16 = !is.adjacent.active(anet, iov[4,2], iov[4,1], at=-Inf) # at Inf
b17 = !is.adjacent.active(anet, iov[4,2], iov[4,1], at=10) # at a
b18 = !is.adjacent.active(anet, iov[7,2], iov[7,1], at=10) # at a
b19 = !is.adjacent.active(anet, iov[7,2], iov[7,1], at=30) # at a
b20 = !is.adjacent.active(anet, iov[7,2], iov[7,1], at=30) # at b
b21 = !is.adjacent.active(anet, iov[7,2], iov[7,1], at=25) # at M
b22 = !is.adjacent.active(anet, iov[3,2], iov[3,1], at=10) # at M
b23 = !is.adjacent.active(anet, iov[4,2], iov[4,1], at=25) # at M
# tests that should return false for point queries b/c of non-activity
b24 = !is.adjacent.active(anet, iov[4,1], iov[4,2], at=-Inf, active.default=F) # at -Inf
b25 = !is.adjacent.active(anet, iov[6,1], iov[6,2], at=-Inf, active.default=F) # at -Inf
b26 = !is.adjacent.active(anet, iov[3,1], iov[3,2], at=Inf, active.default=F) # at Inf
b27 = !is.adjacent.active(anet, iov[5,1], iov[5,2], at=Inf, active.default=F) # at Inf
b28 = !is.adjacent.active(anet, iov[3,1], iov[3,2], at=20, active.default=F) # at b
b29 = !is.adjacent.active(anet, iov[5,1], iov[5,2], at=20, active.default=F) # at b
b30 = !is.adjacent.active(anet, iov[3,1], iov[3,2], at=25, active.default=F) # at H
b31 = !is.adjacent.active(anet, iov[7,1], iov[7,2], at=35, active.default=F) # at H
b32 = !is.adjacent.active(anet, iov[1,1], iov[1,2], at=25, active.default=F) # at H
b.tests = paste("b", seq(1,32), sep="")
b.results= sapply(b.tests, function(x){eval(parse(text=x))})
if(any(!b.results)){
bad.tests = paste("b", which(!b.results), sep="", collapse=" ")
stop(paste("is.ajacent.active is incorrectly activating edges in tests",
bad.tests))
}
# tests that should return true for interval queries
c1 = is.adjacent.active(anet, iov[1,1], iov[1,2], -Inf, Inf) # over (-Inf,Inf)
c2 = is.adjacent.active(anet, iov[2,1], iov[2,2], -Inf, Inf) # over (-Inf,Inf)
c3 = is.adjacent.active(anet, iov[3,1], iov[3,2], -Inf, 20) # over (-Inf, b)
c4 = is.adjacent.active(anet, iov[3,1], iov[3,2], -Inf, 30) # over (-Inf, H)
c5 = is.adjacent.active(anet, iov[4,1], iov[4,2], 0, Inf) # over (L, Inf)
c6 = is.adjacent.active(anet, iov[4,1], iov[4,2], 10, Inf) # over (a, Inf)
c7 = is.adjacent.active(anet, iov[5,1], iov[5,2], 10,20) # over (a, b)
c8 = is.adjacent.active(anet, iov[7,1], iov[7,2], 10,30) # over (a, b)
c9 = is.adjacent.active(anet, iov[6,1], iov[6,2], 10,10) # over (a, a)
c10 = is.adjacent.active(anet, iov[7,1], iov[7,2], 0, 40) # over (L, H)
# tests that should return false for interval queries b/c of non-adjacency
c11 = !is.adjacent.active(anet, iov[1,2], iov[1,1], -Inf, Inf) # over (-Inf,Inf)
c12 = !is.adjacent.active(anet, iov[2,2], iov[2,1], -Inf, Inf) # over (-Inf,Inf)
c13 = !is.adjacent.active(anet, iov[3,2], iov[3,1], -Inf, 20) # over (-Inf, b)
c14 = !is.adjacent.active(anet, iov[3,2], iov[3,1], -Inf, 30) # over (-Inf, H)
c15 = !is.adjacent.active(anet, iov[4,2], iov[4,1], 0, Inf) # over (L, Inf)
c16 = !is.adjacent.active(anet, iov[4,2], iov[4,1], 10, Inf) # over (a, Inf)
c17 = !is.adjacent.active(anet, iov[5,2], iov[5,1], 10,20) # over (a, b)
c18 = !is.adjacent.active(anet, iov[7,2], iov[7,1], 10,30) # over (a, b)
c19 = !is.adjacent.active(anet, iov[6,2], iov[6,1], 10,10) # over (a, a)
c20 = !is.adjacent.active(anet, iov[7,2], iov[7,1], 0, 40) # over (L, H)
# tests that should return false for interval queries b/c of non-activity
c21 = !is.adjacent.active(anet, iov[1,1], iov[1,2], -Inf, Inf, active.default=F) # over (-Inf,Inf)
c22 = !is.adjacent.active(anet, iov[8,1], iov[8,2], -Inf, Inf, active.default=F) # over (-Inf,Inf)
c23 = !is.adjacent.active(anet, iov[3,1], iov[3,2], -Inf, 30, rule="all", active.default=F) # over (-Inf, H)
c24 = !is.adjacent.active(anet, iov[4,1], iov[4,2], 0, Inf, rule="all", active.default=F) # over (L, Inf)
c25 = !is.adjacent.active(anet, iov[5,1], iov[5,2], 10, Inf, rule="all", active.default=F) # over (a, Inf)
c26 = !is.adjacent.active(anet, iov[5,1], iov[5,2], 20,20, active.default=F) # over (b, b)
c27 = !is.adjacent.active(anet, iov[5,1], iov[5,2], 0, 5, active.default=F) # over (L, L)
c28 = !is.adjacent.active(anet, iov[7,1], iov[7,2], 0,35, rule="all", active.default=F) # over (L, H)
c.tests = paste("c", seq(1,28), sep="")
c.results= sapply(c.tests, function(x){eval(parse(text=x))})
if(any(!c.results)){
bad.tests = paste("c", which(!b.results), sep="", collapse=" ")
stop(paste("activate.edges is incorrectly activating edges in tests",
bad.tests))
}
expect_false(is.adjacent.active(network.initialize(0),1))
# ----- tests for spells.overlap ------
# |----|
# |----|
expect_true(spells.overlap(c(1,2),c(1,2)))
# |----|
# |----|
expect_true(spells.overlap(c(1,3),c(0,2)))
# |----|
# |----|
expect_true(spells.overlap(c(0,2),c(1,3)))
# |----|
# |--|
expect_true(spells.overlap(c(0,3),c(1,2)))
# |--|
# |----|
expect_true(spells.overlap(c(1,2),c(0,3)))
# |--|
# |---|
expect_true(spells.overlap(c(1,3),c(0,3)))
# |---|
# |--|
expect_true(spells.overlap(c(0,3),c(1,3)))
# |--|
# |---|
expect_true(spells.overlap(c(0,2),c(0,3)))
# |---|
# |--|
expect_true(spells.overlap(c(0,3),c(0,2)))
# null spell
# valid spell
expect_false(spells.overlap(c(-Inf,-Inf),c(1,3)))
expect_false(spells.overlap(c(Inf,Inf),c(1,3)))
# valid spell
# null spell
expect_false(spells.overlap(c(1,3),c(-Inf,-Inf)))
expect_false(spells.overlap(c(1,3),c(Inf,Inf)))
# |---|
# |--|
expect_false(spells.overlap(c(0,2),c(3,5)))
# |---|
# |--|
expect_false(spells.overlap(c(3,5),c(0,2)))
# |---|
# |--|
expect_false(spells.overlap(c(3,5),c(0,3)))
# |---|
# |--|
expect_false(spells.overlap(c(0,3),c(3,5)))
# point queries
# |
# |--|
expect_false(spells.overlap(c(0,0),c(1,3)))
# |
# |--|
expect_true(spells.overlap(c(1,1),c(1,3)))
# |
# |--|
expect_true(spells.overlap(c(2,2),c(1,3)))
# |
# |--|
expect_false(spells.overlap(c(3,3),c(1,3)))
# |
# |--|
expect_false(spells.overlap(c(5,5),c(1,3)))
# |
# |
expect_false(spells.overlap(c(1,1),c(2,2)))
# |
# |
expect_true(spells.overlap(c(1,1),c(1,1)))
# |
# |
expect_false(spells.overlap(c(2,2),c(1,1)))
# |--|
# |
expect_false(spells.overlap(c(1,3),c(0,0)))
# |--|
# |
expect_true(spells.overlap(c(1,3),c(1,1)))
# |--|
# |
expect_true(spells.overlap(c(1,3),c(2,2)))
# |--|
# |
expect_false(spells.overlap(c(1,3),c(3,3)))
# |--|
# |
expect_false(spells.overlap(c(1,3),c(4,4)))
# ------ tests for spells.hit ----
expect_error(spells.hit(c(1,2), matrix(ncol=2,nrow=0)),regexp = 'must have at least one row')
expect_error(spells.hit(c(1,2,3), c(1,2)),regexp = 'must have exactly two elements')
expect_error(spells.hit(c(1,2), matrix(ncol=3,nrow=1)),regexp = 'must have exactly two columns')
expect_equal(spells.hit(c(1,2), matrix(c(3,5,
6,7),ncol=2,byrow=TRUE)),-1)
expect_equal(spells.hit(c(1,4), matrix(c(3,5,
6,7),ncol=2,byrow=TRUE)),1)
expect_equal(spells.hit(c(5,5), matrix(c(3,5,
6,7),ncol=2,byrow=TRUE)),-1)
expect_equal(spells.hit(c(1,7), matrix(c(3,5,
6,7),ncol=2,byrow=TRUE)),1)
expect_equal(spells.hit(c(5.5,7), matrix(c(3,5,
6,7),ncol=2,byrow=TRUE)),2)
cat("ok\n")
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.