# tests/testthat/test-galois_field.R In lhs: Latin Hypercube Samples

```test_that("Galois Fields Work", {
test_field <- function(q, p, n)
{
gf <- create_galois_field(q)
expect_equal(gf\$p, p)
expect_equal(gf\$q, q)
expect_equal(gf\$n, n)
}

test_field(2, 2, 1)
test_field(3, 3, 1)
test_field(4, 2, 2)
test_field(9, 3, 2)

# q cannot be less than 2
expect_error(create_galois_field(-1))
expect_error(create_galois_field(1))
# q must be a prime power
expect_error(create_galois_field(100000000))
expect_error(create_galois_field(35))
# the prime power can't be too large
expect_error(create_galois_field(2^30))
})

test_that("Associative", {
check_associative <- function(gf){
for (i in 1:gf\$q)
{
for (j in 1:gf\$q)
{
for (k in 1:gf\$q)
{
sum1 <- poly_sum(gf\$p, gf\$n, gf\$poly[i,], gf\$poly[j,])
sum2 <- poly_sum(gf\$p, gf\$n, sum1, gf\$poly[k,])
sum3 <- poly_sum(gf\$p, gf\$n, gf\$poly[j,], gf\$poly[k,])
sum4 <- poly_sum(gf\$p, gf\$n, gf\$poly[i,], sum3)
expect_equal(sum2, sum4)

prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], gf\$poly[j,])
prod2 <- poly_prod(gf\$p, gf\$n, gf\$xton, prod1, gf\$poly[k,])
prod3 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[j,], gf\$poly[k,])
prod4 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], prod3)
expect_equal(prod2, prod4)

}
}
}
}
check_associative(create_galois_field(3))
check_associative(create_galois_field(4))
check_associative(create_galois_field(9))
check_associative(create_galois_field(8))
})

test_that("Commutative", {
check_commutative <- function(gf)
{
for (i in 1:gf\$q)
{
for (j in 1:gf\$q)
{
sum1 <- poly_sum(gf\$p, gf\$n, gf\$poly[i,], gf\$poly[j,])
sum2 <- poly_sum(gf\$p, gf\$n, gf\$poly[j,], gf\$poly[i,])
expect_equal(sum1, sum2)

prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], gf\$poly[j,])
prod2 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[j,], gf\$poly[i,])
expect_equal(prod1, prod2)
}
}
}
check_commutative(create_galois_field(3))
check_commutative(create_galois_field(4))
check_commutative(create_galois_field(9))
check_commutative(create_galois_field(8))
})

test_that("Identity", {
check_identity <- function(gf, zero, one)
{
for (i in 1:gf\$q)
{
sum1 <- poly_sum(gf\$p, gf\$n, gf\$poly[i,], zero)
expect_equal(sum1, gf\$poly[i,])
prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], one)
expect_equal(prod1, gf\$poly[i,])
}
}
check_identity(create_galois_field(3), 0, 1)
check_identity(create_galois_field(4), c(0,0), c(1,0))
check_identity(create_galois_field(9), c(0,0), c(1,0))
check_identity(create_galois_field(8), c(0,0,0), c(1,0,0))
})

test_that("Inverse", {
check_inverse <- function(gf, zero, one)
{
#gf <- create_galois_field(3)
for (i in 1:gf\$q)
{
#i <- 1
sum1 <- poly_sum(gf\$p, gf\$n, gf\$poly[i,], gf\$poly[gf\$neg[i] + 1,])
expect_equal(sum1, zero)
if (!is.na(gf\$inv[i]))
{
prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], gf\$poly[gf\$inv[i] + 1,])
expect_equal(prod1, one)
}
}
}
check_inverse(create_galois_field(3), 0, 1)
check_inverse(create_galois_field(4), c(0,0), c(1,0))
check_inverse(create_galois_field(9), c(0,0), c(1,0))
check_inverse(create_galois_field(8), c(0,0,0), c(1,0,0))
})

test_that("Distributive", {
check_distributive <- function(gf)
{
for (i in 1:gf\$q)
{
for (j in 1:gf\$q)
{
for (k in 1:gf\$q)
{
sum1 <- poly_sum(gf\$p, gf\$n, gf\$poly[j,], gf\$poly[k,])
prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], sum1)
prod2 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], gf\$poly[j,])
prod3 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[i,], gf\$poly[k,])
sum2 <- poly_sum(gf\$p, gf\$n, prod2, prod3)
expect_equal(prod1, sum2)
}
}
}
}
check_distributive(create_galois_field(3))
check_distributive(create_galois_field(4))
check_distributive(create_galois_field(9))
check_distributive(create_galois_field(8))
})

test_that("Roots", {
check_roots <- function(gf)
{
#gf <- create_galois_field(3)
for (i in 1:gf\$q)
{
if (!is.na(gf\$root[i])){
prod1 <- poly_prod(gf\$p, gf\$n, gf\$xton, gf\$poly[gf\$root[i] + 1,], gf\$poly[gf\$root[i] + 1,])
expect_equal(gf\$poly[i, ], prod1)
}
}
}
check_roots(create_galois_field(3))
check_roots(create_galois_field(4))
check_roots(create_galois_field(9))
check_roots(create_galois_field(8))
})
```

## Try the lhs package in your browser

Any scripts or data that you put into this service are public.

lhs documentation built on Dec. 28, 2022, 2:59 a.m.