test_STR.R
In stR: STR Decomposition

test_that("Test 1", {

seasonalStructure = list(segments = list(c(1,4)), sKnots = list(c(1, 4), 2, 3))
toTest = as.matrix(seasonalTransformer(nKnots = 3, seasonalStructure = seasonalStructure))

v1 = c(1,    0,    0,    0,    0,    0)
v2 = c(0,    1,    0,    0,    0,    0)
v3 = c(-1,   -1,  0,     0,    0,    0)
v4 = c(0,    0,    1,    0,    0,    0)
v5 = c(0,    0,    0,    1,    0,    0)
v6 = c(0,    0,   -1,   -1,    0,    0)
v7 = c(0,    0,    0,    0,    1,    0)
v8 = c(0,    0,    0,    0,    0,    1)
v9 = c(0,    0,    0,    0,   -1,   -1)

toCompare = rbind(v1, v2, v3, v4, v5, v6, v7, v8, v9)

expect_false(!identical(dim(toTest), dim(toCompare)) || sum(toTest != toCompare)>0)

seasonalStructure = list(segments = list(c(1,6)), sKnots = list(c(1, 6), 2, 3))
toTest = as.matrix(seasonalTransformer(nKnots = 3, seasonalStructure = seasonalStructure))

v1 = c(1,    0,    0,    0,    0,    0)
v2 = c(0,    1,    0,    0,    0,    0)
v3 = c(-1,   -0.5,  0,     0,    0,    0)
v4 = c(0,    0,    1,    0,    0,    0)
v5 = c(0,    0,    0,    1,    0,    0)
v6 = c(0,    0,   -1,   -0.5,    0,    0)
v7 = c(0,    0,    0,    0,    1,    0)
v8 = c(0,    0,    0,    0,    0,    1)
v9 = c(0,    0,    0,    0,   -1,   -0.5)

toCompare = rbind(v1, v2, v3, v4, v5, v6, v7, v8, v9)

expect_false(!identical(dim(toTest), dim(toCompare)) || sum(toTest != toCompare)>0)

seasonalStructure = list(segments = list(c(0,5)), sKnots = list(3, 4, c(0, 5)))
toTest = as.matrix (seasonalTransformer(nKnots = 3, seasonalStructure = seasonalStructure))

v1 = c(1,    0,    0,    0,    0,    0)
v2 = c(0,    1,    0,    0,    0,    0)
v3 = c(-1,   -0.5,  0,     0,    0,    0)
v4 = c(0,    0,    1,    0,    0,    0)
v5 = c(0,    0,    0,    1,    0,    0)
v6 = c(0,    0,   -1,   -0.5,    0,    0)
v7 = c(0,    0,    0,    0,    1,    0)
v8 = c(0,    0,    0,    0,    0,    1)
v9 = c(0,    0,    0,    0,   -1,   -0.5)

toCompare = rbind(v1, v2, v3, v4, v5, v6, v7, v8, v9)

expect_false(!identical(dim(toTest), dim(toCompare)) || sum(toTest != toCompare)>0)

seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1, 4, c(0, 5)))
toTest = as.matrix (seasonalTransformer(nKnots = 3, seasonalStructure = seasonalStructure))

v1 = c(1,    0,    0,    0,    0,    0)
v2 = c(0,    1,    0,    0,    0,    0)
v3 = c(-2,   -2,  0,     0,    0,    0)
v4 = c(0,    0,    1,    0,    0,    0)
v5 = c(0,    0,    0,    1,    0,    0)
v6 = c(0,    0,   -2,   -2,    0,    0)
v7 = c(0,    0,    0,    0,    1,    0)
v8 = c(0,    0,    0,    0,    0,    1)
v9 = c(0,    0,    0,    0,   -2,   -2)

toCompare = rbind(v1, v2, v3, v4, v5, v6, v7, v8, v9)

expect_false(!identical(dim(toTest), dim(toCompare)) || sum(toTest != toCompare)>0)

seasonalStructure = list(segments = list(c(0,5)), sKnots = list(2, 4, c(0, 5)))
toTest = as.matrix (seasonalTransformer(nKnots = 3, seasonalStructure = seasonalStructure))

v1 = c(1,    0,    0,    0,    0,    0)
v2 = c(0,    1,    0,    0,    0,    0)
v3 = c(-4/3,   -1,  0,     0,    0,    0)
v4 = c(0,    0,    1,    0,    0,    0)
v5 = c(0,    0,    0,    1,    0,    0)
v6 = c(0,    0,   -4/3,   -1,    0,    0)
v7 = c(0,    0,    0,    0,    1,    0)
v8 = c(0,    0,    0,    0,    0,    1)
v9 = c(0,    0,    0,    0,   -4/3,   -1)

toCompare = rbind(v1, v2, v3, v4, v5, v6, v7, v8, v9)

expect_false(!identical(dim(toTest), dim(toCompare)) || sum(toTest != toCompare)>0)

})


test_that("Test 2", {

toTest = as.matrix(seasonalTransposer(nKnots = 3, nSKnots = 3))
m = matrix(1:9, 3, 3)

v1 = as.vector(toTest %*% as.vector(m))
v2 = as.vector(t(m))
expect_false(!identical(length(v1), length(v2)) || sum(v1 != v2)>0)

for(nk in 1:10) {
  for(nsk in 2:10) {
    toTest = as.matrix(seasonalTransposer(nk, nsk))
    m = matrix(1:(nk*nsk), nsk, nk)

    v1 = as.vector(toTest %*% as.vector(m))
    v2 = as.vector(t(m))
    expect_false(!identical(length(v1), length(v2)) || sum(v1 != v2)>0)
  }
}

})


test_that("Test 3", {

times = c(1,2,5,9,9.5,10)
data = rep(1, length(times))
seasons = rep(0, length(times))
timeKnots = c(1,3,10)

seasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(0,1)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)

matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))

vk = c(1,3,10)
toTest = as.vector(matrixToTest %*% vk)

expect_true(sum(abs(toTest - times) > 1E-6) == 0)
expect_true(length(toTest) == length(times))

# Now let's test with 2 time knots

timeKnots = c(1,10)
seasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(0,1)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)

matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))

vk = c(1,10)
toTest = as.vector(matrixToTest %*% vk)

expect_true(length(toTest) == length(times))
expect_true(sum(abs(toTest - times) > 1E-6) == 0)

# Testing with no time knots (static predictor)

times = c(1,2,5,9,9.5,10)
data = times
seasons = NULL
timeKnots = NULL

seasonalStructure = NULL
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)

matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))

vk = c(1)
toTest = as.vector(matrixToTest %*% vk)

expect_true(length(toTest) == length(times))
expect_true(sum(abs(toTest - times) > 1E-6) == 0)

# Testing static predictor

times = c(1,2,5,9,9.5,10)
data = times
data_ = data + c(0.1,-0.2,0.3,0.1,-0.3,0)
seasons = NULL
timeKnots = NULL

seasonalStructure = NULL
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(0,0,0))

str = STRmodel(data = data_, predictors = list(predictor))
# plot(str)

#############################################

timeKnots = c(1,5,9)
times = 1:9
seasons = c(2,3,1,2,3,1,2,3,1)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,3)), sKnots = list(1,2,c(3,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-1,0,-1,0,-1,0)
toCompare = c(0,1,-1,0,1,-1,0,1,-1)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

timeKnots = c(1,5,9)
times = 1:6
seasons = c(2,1,2,1,2,1)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,2)), sKnots = list(1,c(2,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-1,-1,-1)
toCompare = c(1,-1,1,-1,1,-1)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

timeKnots = c(1,5,9,15)
seasons = c(2,3,4,5,1,2,3,4,5,1,2,3,4,5,1)
times = seq_along(seasons)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-2,-1,0,1,-2,-1,0,1,-2,-1,0,1,-2,-1,0,1)
toCompare = c(-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

timeKnots = c(1,8,15)
seasons = c(2,3,4,5,1,2,3,4,5,1,2,3,4,5,1)
times = seq_along(seasons)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-2,0,1,-2,0,1,-2,0,1)
toCompare = c(-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

timeKnots = c(1,8,15)
seasons = c(2,3,4,5,1,2,3,4,5,1,2,3,4,5,1)
times = seq_along(seasons)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-2,-1,1,-2,-1,1,-2,-1,1)
toCompare = c(-2,-1,1,2,0,-2,-1,1,2,0,-2,-1,1,2,0)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

timeKnots = c(1,8,15)
seasons = c(2,3,4,5,1,2,3,4,5,1,2,3,4,5,1)
times = seq_along(seasons)
data = rep(1, length(times))
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-2,-1,1,0,0,0,-2,-1,1)
toCompare = c(-2,-1*(6/7),1*(5/7),2*(4/7),0*(3/7),-2*(2/7),-1*(1/7), 1*0 ,2*(1/7),0*(2/7),-2*(3/7),-1*(4/7),1*(5/7),2*(6/7),0)
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

})


test_that("Test 4", {

data = c(7,3,1,5,3)
timeKnots = c(1,2,3,5)
seasons = rep(0, length(data))
times = seq_along(seasons)
seasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(0,1)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = rep(1, length(timeKnots))
expect_true(all(abs(matrixToTest %*% v - data) < 1E-6))

data = c(7,3,1,5,3)
timeKnots = c(1,4,5)
seasons = rep(0, length(data))
times = seq_along(seasons)
seasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(0,1)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = rep(1, length(timeKnots))
expect_true(all(abs(matrixToTest %*% v - data) < 1E-6))

#############################################

timeKnots = c(1,5,9)
times = 1:9
seasons = c(2,3,1,2,3,1,2,3,1)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,3)), sKnots = list(1,2,c(3,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-1,0,-1,0,-1,0)
toCompare = c(0,1,-1,0,1,-1,0,1,-1) * data
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == 9))

timeKnots = c(1,8,15)
seasons = c(2,3,4,5,1,2,3,4,5,1,2,3,4,5,1)
times = seq_along(seasons)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(seasonalPredictorConstructor(predictor))
v = c(-2,-1,1,0,0,0,-2,-1,1)
toCompare = c(-2,-1*(6/7),1*(5/7),2*(4/7),0*(3/7),-2*(2/7),-1*(1/7), 1*0 ,2*(1/7),0*(2/7),-2*(3/7),-1*(4/7),1*(5/7),2*(6/7),0) * data
toTest = matrixToTest %*% v
expect_false(!(sum(abs(toTest - toCompare) > 1E-6) == 0 && length(toTest) == length(toCompare)))

})


test_that("Test 5", {

n = 5
v = 1:n
expect_true(all(abs(as.matrix(diff1(n)) %*% v - rep(1, n-1)) < 1E-6))

n = 25
v = 1:n
expect_true(all(abs(as.matrix(diff2(n)) %*% v - rep(0, n-2)) < 1E-6))

})


test_that("Test 6", {

knots = c(1,3,5,7,9)
vd = as.matrix(vector2Derivatives(knots, weights = rep(1, length(knots)-2)))
expect_true(all(abs(vd %*% knots - rep(0, length(knots)-2)) < 1E-6))

knots = c(1,5,7,9)
vd = as.matrix(vector2Derivatives(knots, weights = rep(1, length(knots)-2)))
expect_true(all(abs(vd %*% knots - rep(0, length(knots)-2)) < 1E-6))

knots = c(1,8.9,9)
vd = as.matrix(vector2Derivatives(knots, weights = rep(1, length(knots)-2)))
expect_true(all(abs(vd %*% knots - rep(0, length(knots)-2)) < 1E-6))

knots = c(1,8.9,9)
vd = as.matrix(vector2Derivatives(knots, weights = rep(1, length(knots)-2)))
expect_true(all(abs(vd %*% (knots^2) - rep(2, length(knots)-2)) < 1E-6))

knots = c(1,8.9,9,12,14,15,16)
vd = as.matrix(vector2Derivatives(knots, weights = rep(1, length(knots)-2)))
expect_true(all(abs(vd %*% (knots^2) - rep(2, length(knots)-2)) < 1E-6))

knots = c(1,8.9,9,12,14,15,16)
vd = as.matrix(vector2Derivatives(knots, weights = rep(0.5, length(knots)-2)))
expect_true(all(abs(vd %*% (knots^2) - rep(1, length(knots)-2)) < 1E-6))

})


test_that("Test 7", {

seasonalStructure = list(segments = list(c(0,24), c(100,124), c(212,224), c(312,324)),
                         sKnots = list(c(0,24,324),4,8,c(12, 212),16,20,c(100,124,224),104,108,c(112,312),116,120,216,220,316,320)
)

lrk = lrKnots(seasonalStructure)
lk = list(c(NA,20,320),0,4,c(8, NA),12,16,c(NA,120,220),100,104,c(108,NA),112,116,212,216,312,316)
rk = list(c(4,NA,NA),8,12,c(16, 216),20,24,c(104,NA,NA),108,112,c(116,316),120,124,220,224,320,324)
expect_true(length(lrk$lKnots) == length(lk))
expect_true(length(lrk$rKnots) == length(rk))
expect_true(sum(!unlist(lapply(seq_along(lrk$lKnots), function(i) identical(lk[[i]], lrk$lKnots[[i]])))) == 0)
expect_true(sum(!unlist(lapply(seq_along(lrk$rKnots), function(i) identical(rk[[i]], lrk$rKnots[[i]])))) == 0)

expect_true(knotToIndex(0, seasonalStructure$sKnots) == 1)
expect_true(knotToIndex(4, seasonalStructure$sKnots) == 2)
expect_true(knotToIndex(8, seasonalStructure$sKnots) == 3)
expect_true(knotToIndex(12, seasonalStructure$sKnots) == 4)
expect_true(knotToIndex(16, seasonalStructure$sKnots) == 5)
expect_true(knotToIndex(20, seasonalStructure$sKnots) == 6)
expect_true(knotToIndex(24, seasonalStructure$sKnots) == 1)
expect_true(knotToIndex(100, seasonalStructure$sKnots) == 7)
expect_true(knotToIndex(104, seasonalStructure$sKnots) == 8)
expect_true(knotToIndex(108, seasonalStructure$sKnots) == 9)
expect_true(knotToIndex(112, seasonalStructure$sKnots) == 10)
expect_true(knotToIndex(116, seasonalStructure$sKnots) == 11)
expect_true(knotToIndex(120, seasonalStructure$sKnots) == 12)
expect_true(knotToIndex(124, seasonalStructure$sKnots) == 7)
expect_true(knotToIndex(212, seasonalStructure$sKnots) == 4)
expect_true(knotToIndex(216, seasonalStructure$sKnots) == 13)
expect_true(knotToIndex(220, seasonalStructure$sKnots) == 14)
expect_true(knotToIndex(224, seasonalStructure$sKnots) == 7)
expect_true(knotToIndex(312, seasonalStructure$sKnots) == 10)
expect_true(knotToIndex(316, seasonalStructure$sKnots) == 15)
expect_true(knotToIndex(320, seasonalStructure$sKnots) == 16)
expect_true(knotToIndex(324, seasonalStructure$sKnots) == 1)

})


test_that("Test 7", {

seasonalStructure = list(segments = list(c(0,24), c(100,124), c(212,224), c(312,324)),
                         sKnots = list(c(0,24,324),4,8,c(12, 212),16,20,c(100,124,224),104,108,c(112,312),116,120,216,220,316,320)
)
tm = as.matrix(cycle2Derivatives(seasonalStructure))
sKnots = seasonalStructure$sKnots
nSKnots = length(sKnots)
v = rep(7.7, nSKnots)
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest) < 1E-6))

seasonalStructure = list(segments = list(c(0,4), c(10,14)),
                         sKnots = list(c(0,4,10,14),1,2,3,11,12,13)
)
tm = as.matrix(cycle2Derivatives(seasonalStructure))
sKnots = seasonalStructure$sKnots
nSKnots = length(sKnots)
expect_true(nSKnots == 7)
v = rep(7.7, nSKnots)
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest) < 1E-6))
expect_true(length(toTest) == 10)

v = c(1,1,1,1,1,2,1)
tm = as.matrix(cycle2Derivatives(seasonalStructure, norm = 1))
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest - c(0,0,0,0,0,0,0,1,-2,1)) < 1E-6))

v = c(1,1,1,1,1,2,1)
tm = as.matrix(cycle2Derivatives(seasonalStructure, norm = 2))
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest - c(0,0,0,0,0,0,0,1,-2,1)) < 1E-6))

v = c(2,1,1,1,1,1,1)
tm = as.matrix(cycle2Derivatives(seasonalStructure, norm = 1))
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest - c(-1,-1,-1,-1,1,0,1,1,0,1)) < 1E-6))

v = c(2,1,1,1,1,1,1)
tm = as.matrix(cycle2Derivatives(seasonalStructure, norm = 2))
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest - c(-sqrt(2),-sqrt(2),-sqrt(2),-sqrt(2),1,0,1,1,0,1)) < 1E-6))

v = c(1,2,1,1,1,1,1)
tm = as.matrix(cycle2Derivatives(seasonalStructure, norm = 1))
toTest = as.vector(tm %*% v)
expect_true(all(abs(toTest - c(0.5,0,0.5,0,-2,1,0,0,0,0)) < 1E-6))

seasonalStructure = list(segments = list(c(0,4)),
                         sKnots = list(1,2,3,c(0,4))
)

c2d = as.matrix(cycle2Derivatives(seasonalStructure, norm = 2))
v = c(0,1,0,1)
expect_true(all(abs(c2d %*% v - 2*c(1,-1,1,-1)) < 1E-6))

})


test_that("Test 8", {

timeKnots = c(1,6,11)
times = 1:11
seasons = c(1,2,3,4,5,1,2,3,4,5)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(ssRegulariser(predictor, norm = 1))

# I do not know how to test it...

})


test_that("Test 9", {

timeKnots = c(1,6,11)
times = 1:11
seasons = c(1,2,3,4,5,1,2,3,4,5)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(ttRegulariser(predictor, norm = 1))

v = c(1,1,1,1,1,1,1,1,1,1,1,1)
toTest = as.vector(matrixToTest %*% v)
expect_true(all(toTest < 1E-6))

v = c(1,1,1,1,2,2,2,2,1,1,1,1)
toTest = as.vector(matrixToTest %*% v)
toCompare = c(-0.4,-0.4,-0.4,-0.4,1.6)
expect_true(all(toTest - toCompare < 1E-6))

})


test_that("Test 10", {

timeKnots = c(1,6,11)
times = 1:11
seasons = c(1,2,3,4,5,1,2,3,4,5)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure)
matrixToTest = as.matrix(stRegulariser(predictor, norm = 1))

v = c(1,1,1,1,1,1,1,1,1,1,1,1)
toTest = as.vector(matrixToTest %*% v)
toCompare = rep(0, 10)
expect_true(all(toTest - toCompare < 1E-6))

v = c(1,1,1,1,2,2,2,2,1,1,1,1)
toTest = as.vector(matrixToTest %*% v)
toCompare = c(0,0,0,-5,5,0,0,0,5,-5)
expect_true(all(toTest - toCompare < 1E-6))

})


test_that("Test 11", {

timeKnots = c(1,6,11)
times = 1:11
seasons = c(1,2,3,4,5,1,2,3,4,5)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(1,2,3))

matrixToTest = as.matrix(predictorRegulariser(predictor))

# I do not know how to test it...

})


test_that("Test 12", {

timeKnots = c(1,6,11)
times = 1:11
seasons = c(1,2,3,4,5,1,2,3,4,5,1)
data = (1:length(times))^2-7
seasonalStructure = list(segments = list(c(0,5)), sKnots = list(1,2,3,4,c(5,0)))
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(1,2,3))
predictors = list(predictor, predictor)

matrixToTest = as.matrix(constructorMatrix(predictors)$matrix)
seats = constructorMatrix(predictors)$seats
matrixToTest2 = as.matrix(regulariserMatrix(predictors)$matrix)
matrixToTest3 = as.matrix(designMatrix(predictors))
matrixToTest4 = designMatrix(predictors)

# I do not know how to test it...

})


test_that("Test 13", {

knots = c(1,2,3,4)
expect_true(all(abs(tWeights(knots, norm = 1) - c(0.5, 1, 1, 0.5)) < 1E-6))

knots = c(1,3,7)
expect_true(all(abs(tWeights(knots, norm = 1) - c(1, 3, 2)) < 1E-6))

})


test_that("Test 14", {

expect_true(translST(s = 1, t = 1, nSKnots = 3) == 1)
expect_true(translST(s = 2, t = 1, nSKnots = 3) == 2)
expect_true(translST(s = 3, t = 1, nSKnots = 3) == 3)
expect_true(translST(s = 1, t = 2, nSKnots = 3) == 4)

})


test_that("Test 15", {

seasonalStructure = list(segments = list(c(0,4)), sKnots = list(1,2,3,c(4,0)))

seasons = c(2,3,4,1,2,3,4,1,2,3,4,1)
times = seq_along(seasons)
data = rep(1, length(seasons))
timeKnots = c(1,5,9)
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(1,2,3))

fullDataVector = c(
  1, -1, 1, -1,
  1, -1, 1, -1,
  1, -1, 1, -1
)
fullDataMatrix = matrix(fullDataVector, 4, 3)
reducedDataMatrix = fullDataMatrix[1:3,]
v = as.vector(reducedDataMatrix)

ssr = as.matrix(ssRegulariser(predictor, norm = 1))
r = ssr %*% v
m = matrix(r, 4, 3)
expect_true(all(m[,1] == 8 * c(-1, 1, -1, 1)))
expect_true(all(m[,2] == 16 * c(-1, 1, -1, 1)))
expect_true(all(m[,3] == 8 * c(-1, 1, -1, 1)))

ttr = as.matrix(ttRegulariser(predictor, norm = 2))
r = ttr %*% v
expect_true(all(abs(r) < 1E-6))

str = as.matrix(stRegulariser(predictor, norm = 2))
r = str %*% v
expect_true(all(abs(r) < 1E-6))

#############################################

fullDataVector = c(
  1, -1, 1, -1,
  2, -2, 2, -2,
  3, -3, 3, -3
)
fullDataMatrix = matrix(fullDataVector, 4, 3)
reducedDataMatrix = fullDataMatrix[1:3,]
v = as.vector(reducedDataMatrix)

ssr = as.matrix(ssRegulariser(predictor, norm = 1))
r = ssr %*% v
m = matrix(r, 4, 3)
expect_true(all(m[,1] == 8 * c(-1, 1, -1, 1)))
expect_true(all(m[,2] == 32 * c(-1, 1, -1, 1)))
expect_true(all(m[,3] == 24 * c(-1, 1, -1, 1)))

ttr = as.matrix(ttRegulariser(predictor, norm = 2))
r = ttr %*% v
expect_true(all(abs(r) < 1E-6))

str = as.matrix(stRegulariser(predictor, norm = 1))
r = str %*% v
m = matrix(r, 4, 2)
expect_true(all(m[,1] == 2 * c(-1, 1, -1, 1)))
expect_true(all(m[,2] == 2 * c(-1, 1, -1, 1)))

#############################################

fullDataVector = c(
  1, -1, 1, -1,
  -1, 1, -1, 1,
  1, -1, 1, -1
)
fullDataMatrix = matrix(fullDataVector, 4, 3)
reducedDataMatrix = fullDataMatrix[1:3,]
v = as.vector(reducedDataMatrix)

ssr = as.matrix(ssRegulariser(predictor, norm = 1))
r = ssr %*% v
m = matrix(r, 4, 3)
expect_true(all(m[,1] == 8 * c(-1, 1, -1, 1)))
expect_true(all(m[,2] == -16 * c(-1, 1, -1, 1)))
expect_true(all(m[,3] == 8 * c(-1, 1, -1, 1)))

ttr = as.matrix(ttRegulariser(predictor, norm = 1))
r = ttr %*% v
expect_true(all(r == c(1, -1, 1, -1)))

str = as.matrix(stRegulariser(predictor, norm = 1))
r = str %*% v
m = matrix(r, 4, 2)
expect_true(all(m[,1] == 4 * c(1, -1, 1, -1)))
expect_true(all(m[,2] == -4 * c(1, -1, 1, -1)))

})


test_that("Test 18", {

seasonalStructure = list(segments = list(c(0,4)), sKnots = list(1,3,c(4,0)))

seasons = c(2,3,4,1,2,3,4,1,2,3,4,1)
times = seq_along(seasons)
data = rep(1, length(seasons))
timeKnots = c(1,7,9)
predictor = list(data = data, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(5,0,2))

fullDataVector = c(
  1, -1, 0,
  -1, 1, 0,
  1, -1, 0
)
fullDataMatrix = matrix(fullDataVector, 3, 3)
reducedDataMatrix = fullDataMatrix[1:2,]
v = as.vector(reducedDataMatrix)

ssr = as.matrix(ssRegulariser(predictor, norm = 2))
r = ssr %*% v
m = matrix(r, 3, 3)

dts12 = (1/6 + 1/2)*2
w2s = 1.5
w1t = 3
dw12 = dts12*sqrt(w2s*w1t)
rv = c(-dw12, dw12, 0)
expect_true(all(abs(m[,1] - rv) < 1E-6))

w2t = 4
dw22 = dts12*sqrt(w2s*w2t)
rv = c(dw22, -dw22, 0)
expect_true(all(abs(m[,2] - rv) < 1E-6))

w3t = 1
dw32 = dts12*sqrt(w2s*w3t)
rv = c(-dw32, dw32, 0)
expect_true(all(abs(m[,3] - rv) < 1E-6))

ttr = as.matrix(ttRegulariser(predictor, norm = 2))
r = ttr %*% v
d = 1/3
dw = d * sqrt(4*1.5)
rv = c(dw, -dw, 0)
expect_true(all(abs(r - rv) < 1E-6))

str = as.matrix(stRegulariser(predictor, norm = 2))
r = str %*% v
m = matrix(r, 3, 2)

rv1 = c(2/sqrt(3), -2/sqrt(6), -2/sqrt(6))
expect_true(all(abs(m[,1] - rv1) < 1E-6))
rv2 = c(-2, 2/sqrt(2), 2/sqrt(2))
expect_true(all(abs(m[,2] - rv2) < 1E-6))

})


test_that("Test 19", {

l = list(list(data = c(1,3,4,5)), list(data = c(4,7,0,2)))
expect_true(all(getLimits(l) == c(0, 7)))

})


test_that("Test 20", {

n = 5
trendSeasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(1,0)))
trend = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = trendSeasonalStructure, lambdas = c(1,0,0))

toTest = as.matrix(ttRegulariser(trend, norm = 2))

v = 1:n
expect_true(all(abs(toTest %*% v) < 1E-6))

})


test_that("Test 21", {

for(n in 55:71) {
  trendSeasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(1,0)))
  timeKnots1 = 1:n
  trend1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = trendSeasonalStructure, lambdas = c(1,0,0))
  timeKnots2 = sort(union(seq(1, n, by = 2), c(1,2,n,n-1)))
  trend2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = trendSeasonalStructure, lambdas = c(1,0,0))

  times3 = seq(1, n, by = 3)
  times4 = seq(1, n, by = 3)
  timeKnots3 = sort(union(setdiff(setdiff(timeKnots1, times3),times4),c(1,2,n-1,n)))
  trend3 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots3, seasonalStructure = trendSeasonalStructure, lambdas = c(1,0,0))

  toTest1 = as.matrix(ttRegulariser(trend1, norm = 1))
  toTest2 = as.matrix(ttRegulariser(trend2, norm = 1))
  toTest3 = as.matrix(ttRegulariser(trend3, norm = 1))

  v1 = ((1:n)/n)^2
  v2 = v1[timeKnots2]
  v3 = v1[timeKnots3]
  expect_true(abs(sum(abs(toTest1 %*% v1))/sum(abs(toTest2 %*% v2)) - 1) < 1E-5)
  expect_true(abs(sum(abs(toTest1 %*% v1))/sum(abs(toTest3 %*% v3)) - 1) < 1E-5)

  toTest1 = as.matrix(ttRegulariser(trend1, norm = 2))
  toTest2 = as.matrix(ttRegulariser(trend2, norm = 2))
  toTest3 = as.matrix(ttRegulariser(trend3, norm = 2))

  expect_true(abs(sum((toTest1 %*% v1)^2)/sum((toTest2 %*% v2)^2) - 1) < 1E-5)
  expect_true(abs(sum((toTest1 %*% v1)^2)/sum((toTest3 %*% v3)^2) - 1) < 1E-5)
}

})


test_that("Test 22", {

n = 101
by = 0.1
sKnots = c(as.list(setdiff(seq(0,1,by = by), c(0,1))), list(c(1,0)))
seasonalStructure = list(segments = list(c(0,1)), sKnots = sKnots)
timeKnots1 = 1:n
s1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
timeKnots2 = sort(union(seq(1, n, by = 2),c(1,2,n-1,n)))
s2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))

v1 = ((1:n)/n)^2
vv1 = as.vector(sapply(v1, FUN = function(x) rep(x, length(sKnots)-1)))
v2 = v1[timeKnots2]
vv2 = as.vector(sapply(v2, FUN = function(x) rep(x, length(sKnots)-1)))

toTest1 = as.matrix(ttRegulariser(s1, norm = 2))
toTest2 = as.matrix(ttRegulariser(s2, norm = 2))

# length(vv1)
# dim(toTest1)

expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest2 %*% vv2)^2)-1) < 1E-5)

})


test_that("Test 23", {

n = 30
by = 0.005
by2 = 0.0025
intKnots = setdiff(seq(0,1,by = by), c(0,1))
intKnots2 = setdiff(seq(0,1,by = by2), c(0,1))
sKnots = c(as.list(intKnots), list(c(1,0)))
sKnots2 = c(as.list(intKnots2), list(c(1,0)))
seasonalStructure = list(segments = list(c(0,1)), sKnots = sKnots)
seasonalStructure2 = list(segments = list(c(0,1)), sKnots = sKnots2)
timeKnots1 = 1:n
s1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
timeKnots2 = sort(union(seq(1, n, by = 2),c(1,2,n-1,n)))
s2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
s3 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure2, lambdas = c(1,0,0))

sinv = sin(intKnots*2*pi)
sinv2 = sin(intKnots2*2*pi)
expect_true(sum(sinv) < 1E-6)
expect_true(sum(sinv2) < 1E-6)
v1 = ((1:n)/n)^2
vv1 = as.vector(sapply(v1, FUN = function(x) x*sinv))
v2 = v1[timeKnots2]
vv2 = as.vector(sapply(v2, FUN = function(x) x*sinv))
vv3 = as.vector(sapply(v2, FUN = function(x) x*sinv2))

toTest1 = as.matrix(ttRegulariser(s1, norm = 2))
toTest2 = as.matrix(ttRegulariser(s2, norm = 2))
toTest3 = as.matrix(ttRegulariser(s3, norm = 2))

expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest2 %*% vv2)^2)-1) < 1E-5)
expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest3 %*% vv3)^2)-1) < 1E-5)

toTest1 = as.matrix(ttRegulariser(s1, norm = 1))
toTest2 = as.matrix(ttRegulariser(s2, norm = 1))
toTest3 = as.matrix(ttRegulariser(s3, norm = 1))

expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest2 %*% vv2))-1) < 1E-5)
expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest3 %*% vv3))-1) < 1E-4)

})


test_that("Test 24", {

n = 30
k = 100
intSet = 1:(k-1)
intSet2 = setdiff(intSet, seq(1, k-1, by = 3))
intKnots = intSet/k
intKnots2 = intSet2/k
sKnots = c(as.list(intKnots), list(c(1,0)))
sKnots2 = c(as.list(intKnots2), list(c(1,0)))
seasonalStructure = list(segments = list(c(0,1)), sKnots = sKnots)
seasonalStructure2 = list(segments = list(c(0,1)), sKnots = sKnots2)
timeKnots1 = 1:n
s1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
timeKnots2 = sort(union(seq(1, n, by = 2),c(1,2,n-1,n)))
s2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
s3 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure2, lambdas = c(1,0,0))

sinv = sin(intKnots*2*pi)
sinv2 = sin(intKnots2*2*pi)
expect_true(sum(sinv) < 1E-6)
expect_true(sum(sinv2) < 1E-6)
v1 = ((1:n)/n)^2
vv1 = as.vector(sapply(v1, FUN = function(x) x*sinv))
v2 = v1[timeKnots2]
vv2 = as.vector(sapply(v2, FUN = function(x) x*sinv))
vv3 = as.vector(sapply(v2, FUN = function(x) x*sinv2))

toTest1 = as.matrix(ttRegulariser(s1, norm = 2))
toTest2 = as.matrix(ttRegulariser(s2, norm = 2))
toTest3 = as.matrix(ttRegulariser(s3, norm = 2))

expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest2 %*% vv2)^2)-1) < 1E-5)
expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest3 %*% vv3)^2)-1) < 1E-4)

toTest1 = as.matrix(ttRegulariser(s1, norm = 1))
toTest2 = as.matrix(ttRegulariser(s2, norm = 1))
toTest3 = as.matrix(ttRegulariser(s3, norm = 1))

expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest2 %*% vv2))-1) < 1E-5)
expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest3 %*% vv3))-1) < 1E-3)

})


test_that("Test 25", {

n = 30
k = 100
intSet = 1:(k-1)
intSet2 = setdiff(intSet, seq(1, k-1, by = 3))
intKnots = intSet/k
intKnots2 = intSet2/k
sKnots = c(as.list(intKnots), list(c(1,0)))
sKnots2 = c(as.list(intKnots2), list(c(1,0)))
seasonalStructure = list(segments = list(c(0,1)), sKnots = sKnots)
seasonalStructure2 = list(segments = list(c(0,1)), sKnots = sKnots2)
timeKnots1 = 1:n
s1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
timeKnots2 = sort(union(seq(1, n, by = 2),c(1,2,n-1,n)))
s2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
s3 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure2, lambdas = c(1,0,0))

sinv = sin(intKnots*2*pi)
sinv2 = sin(intKnots2*2*pi)
expect_true(sum(sinv) < 1E-6)
expect_true(sum(sinv2) < 1E-6)
v1 = ((1:n)/n)^2
vv1 = as.vector(sapply(v1, FUN = function(x) x*sinv))
v2 = v1[timeKnots2]
vv2 = as.vector(sapply(v2, FUN = function(x) x*sinv))
vv3 = as.vector(sapply(v2, FUN = function(x) x*sinv2))

toTest1 = as.matrix(stRegulariser(s1, norm = 2))
toTest2 = as.matrix(stRegulariser(s2, norm = 2))
toTest3 = as.matrix(stRegulariser(s3, norm = 2))

expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest2 %*% vv2)^2)-1) < 1E-3)
expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest3 %*% vv3)^2)-1) < 5E-2)

toTest1 = as.matrix(stRegulariser(s1, norm = 1))
toTest2 = as.matrix(stRegulariser(s2, norm = 1))
toTest3 = as.matrix(stRegulariser(s3, norm = 1))

expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest2 %*% vv2))-1) < 1E-5)
expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest3 %*% vv3))-1) < 1E-3)

})


test_that("Test 26", {

n = 30
k = 100
intSet = 1:(k-1)
intSet2 = setdiff(intSet, seq(1, k-1, by = 2))
intKnots = intSet/k
intKnots2 = intSet2/k
sKnots = c(as.list(intKnots), list(c(1,0)))
sKnots2 = c(as.list(intKnots2), list(c(1,0)))
seasonalStructure = list(segments = list(c(0,1)), sKnots = sKnots)
seasonalStructure2 = list(segments = list(c(0,1)), sKnots = sKnots2)
timeKnots1 = 1:n
s1 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = 1:n, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
timeKnots2 = sort(union(seq(1, n, by = 2),c(1,2,n-1,n)))
s2 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure, lambdas = c(1,0,0))
s3 = list(data = rep(1, n), times = 1:n, seasons = rep(1, n), timeKnots = timeKnots2, seasonalStructure = seasonalStructure2, lambdas = c(1,0,0))

sinv = sin(intKnots*2*pi)
sinv2 = sin(intKnots2*2*pi)
expect_true(sum(sinv) < 1E-6)
expect_true(sum(sinv2) < 1E-6)
v1 = ((1:n)/n)^2
vv1 = as.vector(sapply(v1, FUN = function(x) x*sinv))
v2 = v1[timeKnots2]
vv2 = as.vector(sapply(v2, FUN = function(x) x*sinv))
vv3 = as.vector(sapply(v2, FUN = function(x) x*sinv2))

toTest1 = as.matrix(ssRegulariser(s1, norm = 2))
toTest2 = as.matrix(ssRegulariser(s2, norm = 2))
toTest3 = as.matrix(ssRegulariser(s3, norm = 2))

expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest2 %*% vv2)^2)-1) < 5E-2)
expect_true(abs(sum((toTest1 %*% vv1)^2)/sum((toTest3 %*% vv3)^2)-1) < 5E-2)

toTest1 = as.matrix(ssRegulariser(s1, norm = 1))
toTest2 = as.matrix(ssRegulariser(s2, norm = 1))
toTest3 = as.matrix(ssRegulariser(s3, norm = 1))

expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest2 %*% vv2))-1) < 5E-2)
expect_true(abs(sum(abs(toTest1 %*% vv1))/sum(abs(toTest3 %*% vv3))-1) < 5E-2)

})


test_that("Test 27", {

n = 50
trendSeasonalStructure = list(segments = list(c(0,1)), sKnots = list(c(1,0)))
ns = 5
seasonalStructure = list(segments = list(c(0,ns)), sKnots = c(as.list(1:(ns-1)),list(c(ns,0))))
seasons = rep(1:ns,n%/%ns+1)[1:n]
trendSeasons = rep(1, length(seasons))
times = seq_along(seasons)
data = seasons + times/4
plot(times, data, type = "l")
timeKnots = times
trendData = rep(1, n)
seasonData = rep(1, n)
trend = list(data = trendData, times = times, seasons = trendSeasons, timeKnots = timeKnots, seasonalStructure = trendSeasonalStructure, lambdas = c(1,0,0))
season = list(data = seasonData, times = times, seasons = seasons, timeKnots = timeKnots, seasonalStructure = seasonalStructure, lambdas = c(10,0,0))
predictors = list(trend, season)

str1 = STRmodel(data, predictors)

# plot(str1$output$random$data, type = "l")
# plot(str1$output$predictors[[1]]$data, type = "l")
# plot(str1$output$predictors[[2]]$data, type = "l")

plot(str1)

oldData = data


data = oldData
data[c(3,4,7,20,24,29,35,37,45)] = NA
plot(times, data, type = "l")
str2 = STRmodel(data, predictors)
plot(str2)

data = data + rnorm(length(data), 0, 0.2)
plot(times, data, type = "l")
str3 = STRmodel(data, predictors)
plot(str3)

str4 = STRmodel(data, predictors, confidence = 0.95)
plot(str4)

})