N: Dedicated counting functions

NR Documentation

Dedicated counting functions

Description

Dedicated counting functions

Usage

N()

n_check(x, .n = NULL, .min = NULL, .max = NULL, .eq = F)

n0(x)

n1(x)

n2(x)

n3(x)

n1p(x)

n2p(x)

n3p(x)

not_n0(x)

not_n1(x)

not_n2(x)

not_n3(x)

not_n1p(x)

not_n2p(x)

not_n3p(x)

nd()

ndots()

nd0(...)

nd1(...)

nd2(...)

nd3(...)

nd1p(...)

nd2p(...)

nd3p(...)

not_nd0(...)

not_nd1(...)

not_nd2(...)

not_nd3(...)

not_nd1p(...)

not_nd2p(...)

not_nd3p(...)

nu(x)

nunq(x)

nu0(x)

nu1(x)

nu2(x)

nu3(x)

nu1p(x)

nu2p(x)

nu3p(x)

not_nu0(x)

not_nu1(x)

not_nu2(x)

not_nu3(x)

not_nu1p(x)

not_nu2p(x)

not_nu3p(x)

nv(...)

nval(...)

nv0(...)

nv1(...)

nv2(...)

nv3(...)

nv1p(...)

nv2p(...)

nv3p(...)

not_nv0(...)

not_nv1(...)

not_nv2(...)

not_nv3(...)

not_nv1p(...)

not_nv2p(...)

not_nv3p(...)

nw(x)

nw0(x)

nw1(x)

nw2(x)

nw3(x)

nw1p(x)

nw2p(x)

nw3p(x)

not_nw0(x)

not_nw1(x)

not_nw2(x)

not_nw3(x)

not_nw1p(x)

not_nw2p(x)

not_nw3p(x)

neq(x, y)

ndif(x, y)

nr(x)

nr0(x)

nr1(x)

nr2(x)

nr3(x)

nr1p(x)

nr2p(x)

nr3p(x)

not_nr0(x)

not_nr1(x)

not_nr2(x)

not_nr3(x)

not_nr1p(x)

not_nr2p(x)

not_nr3p(x)

nc(x)

nc0(x)

nc1(x)

nc2(x)

nc3(x)

nc1p(x)

nc2p(x)

nc3p(x)

not_nc0(x)

not_nc1(x)

not_nc2(x)

not_nc3(x)

not_nc1p(x)

not_nc2p(x)

not_nc3p(x)

nrc(x)

nrc0(x)

nrc1(x)

nrc2(x)

nrc1p(x)

nrc2p(x)

not_nrc0(x)

not_nrc1(x)

not_nrc2p(x)

nr0_nc0(x)

nr0_nc1(x)

nr0_nc2(x)

nr0_nc3(x)

nr0_nc1p(x)

nr0_nc2p(x)

nr0_nc3p(x)

nr1_nc0(x)

nr1_nc1(x)

nr1_nc2(x)

nr1_nc3(x)

nr1_nc1p(x)

nr1_nc2p(x)

nr1_nc3p(x)

nr2_nc0(x)

nr2_nc1(x)

nr2_nc2(x)

nr2_nc3(x)

nr2_nc1p(x)

nr2_nc2p(x)

nr2_nc3p(x)

nr3_nc0(x)

nr3_nc1(x)

nr3_nc2(x)

nr3_nc3(x)

nr1p_nc0(x)

nr1p_nc1(x)

nr1p_nc2(x)

nr1p_nc3(x)

nr1p_nc1p(x)

nr1p_nc2p(x)

nr1p_nc3p(x)

nr2p_nc0(x)

nr2p_nc1(x)

nr2p_nc2(x)

nr2p_nc3(x)

nr2p_nc1p(x)

nr2p_nc2p(x)

nr2p_nc3p(x)

nr3p_nc0(x)

nr3p_nc1(x)

nr3p_nc2(x)

nr3p_nc3(x)

nr3p_nc1p(x)

nr3p_nc2p(x)

nr3p_nc3p(x)

not_nr0_nc0(x)

not_nr0_nc1(x)

not_nr0_nc2(x)

not_nr0_nc3(x)

not_nr0_nc1p(x)

not_nr0_nc2p(x)

not_nr0_nc3p(x)

not_nr1_nc0(x)

not_nr1_nc1(x)

not_nr1_nc2(x)

not_nr1_nc3(x)

not_nr1_nc1p(x)

not_nr1_nc2p(x)

not_nr1_nc3p(x)

not_nr2_nc0(x)

not_nr2_nc1(x)

not_nr2_nc2(x)

not_nr2_nc3(x)

not_nr2_nc1p(x)

not_nr2_nc2p(x)

not_nr2_nc3p(x)

not_nr3_nc0(x)

not_nr3_nc1(x)

not_nr3_nc2(x)

not_nr3_nc3(x)

not_nr3_nc1p(x)

not_nr3_nc2p(x)

not_nr3_nc3p(x)

not_nr1p_nc0(x)

not_nr1p_nc1(x)

not_nr1p_nc2(x)

not_nr1p_nc1p(x)

not_nr1p_nc2p(x)

not_nr1p_nc3p(x)

not_nr2p_nc0(x)

not_nr2p_nc1(x)

not_nr2p_nc2(x)

not_nr2p_nc1p(x)

not_nr2p_nc2p(x)

not_nr2p_nc3p(x)

not_nr3p_nc0(x)

not_nr3p_nc1(x)

not_nr3p_nc2(x)

not_nr3p_nc1p(x)

not_nr3p_nc2p(x)

not_nr3p_nc3p(x)

ndim(x)

ndim0(x)

ndim1(x)

ndim2(x)

ndim3(x)

ndim1p(x)

ndim2p(x)

ndim3p(x)

not_ndim0(x)

not_ndim1(x)

not_ndim2(x)

not_ndim3(x)

not_ndim1p(x)

not_ndim2p(x)

not_ndim3p(x)

nnav(x)

nnav0(x)

nnav1(x)

nnav2(x)

nnav3(x)

nnav1p(x)

nnav2p(x)

nnav3p(x)

not_nnav0(x)

not_nnav1(x)

not_nnav2(x)

not_nnav3(x)

not_nnav1p(x)

not_nnav2p(x)

not_nnav3p(x)

nokv(x)

nokv0(x)

nokv1(x)

nokv2(x)

nokv3(x)

nokv1p(x)

nokv2p(x)

nokv3p(x)

not_nokv0(x)

not_nokv1(x)

not_nokv2(x)

not_nokv3(x)

not_nokv1p(x)

not_nokv2p(x)

not_nokv3p(x)

ns(x)

ns0(x)

ns1(x)

ns2(x)

ns3(x)

ns1p(x)

ns2p(x)

ns3p(x)

not_ns0(x)

not_ns1(x)

not_ns2(x)

not_ns3(x)

not_ns1p(x)

not_ns2p(x)

not_ns3p(x)

...n(
  ...,
  .n = NULL,
  .min = NULL,
  .max = NULL,
  .eq = F,
  .a = F,
  .na = T,
  .vals = NULL,
  .lt = NULL,
  .le = NULL,
  .ge = NULL,
  .gt = NULL
)

...n0(...)

...n1(...)

...n2(...)

...n3(...)

...n1p(...)

...n2p(...)

...n3p(...)

...not_n0(...)

...not_n1(...)

...not_n2(...)

...not_n3(...)

...not_n1p(...)

...not_n2p(...)

...not_n3p(...)

...ns(
  ...,
  .n = NULL,
  .min = NULL,
  .max = NULL,
  .na = T,
  .vals = NULL,
  .lt = NULL,
  .le = NULL,
  .ge = NULL,
  .gt = NULL
)

...minn(
  ...,
  .na = T,
  .vals = NULL,
  .lt = NULL,
  .le = NULL,
  .ge = NULL,
  .gt = NULL
)

...maxn(
  ...,
  .na = T,
  .vals = NULL,
  .lt = NULL,
  .le = NULL,
  .ge = NULL,
  .gt = NULL
)

...neq(
  ...,
  .min = NULL,
  .max = NULL,
  .na = T,
  .vals = NULL,
  .lt = NULL,
  .le = NULL,
  .ge = NULL,
  .gt = NULL
)

...nw(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .na = F, .a = T)

...nt(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .na = F, .a = T)

...nf(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .na = F, .a = T)

...nu(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .na = T, .a = T)

...nr(..., .n = NULL, .min = NULL, .max = NULL, .eq = F)

...nc(..., .n = NULL, .min = NULL, .max = NULL, .eq = F)

...n_ch(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .na = F, .a = T)

...n_nav(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .a = T)

...n_okv(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .a = T)

...nv(..., .n = NULL, .min = NULL, .max = NULL, .eq = F, .a = T)

Arguments

x

For n_check(x), a non-negative whole-number object giving counts. Otherwise, an arbitrary object.

.n

Optional complete non-negative whole-number vec of valid element, row, or column counts.

.min

Optional complete non-negative whole-number scalar giving minimum valid element, row, or column counts.

.max

Optional complete non-negative whole-number scalar giving maximum valid element, row, or column counts.

.eq

Non-NA scalar indicating whether all counts must be equal.

...

One or more arguments to be examined for counts.

.a

Non-NA scalar indicating whether to atomize ... to create a single atomic vector before processing. If .a = F, each argument in ... is processed separately.

.na

Non-NA scalar whether NA values are allowed.

.vals

Optional atomic vec indicating specific values to be counted.

.lt

Optional complete sortable scalar indicating specific values elements of ... arguments must be less than in order to be counted.

.le

Optional complete sortable scalar indicating specific values elements of ... arguments must be less than or equal to in order to be counted

.ge

Optional complete sortable scalar indicating specific values elements of ... arguments must be greater than or equal to in order to be counted.

.gt

Optional complete sortable scalar indicating specific values elements of ... arguments must be greater than in order to be counted.

Details

The following functions are flexible, fully error-checked counting functions with optional count functionality driven by arguments:

  n_check Do counts given in x meet criteria in c(N, .min, .max, .eq), if any? If none, returns x.
   
  ...n Length(s) of ... args with optional length validations.
   
  ...ns Lengths of ... args
  ...nv Length after atomizing.
  ...nch Number of characters in each element.
  ...nrc NROW(x) * NCOL(x)
  ...nnav Number of atomic NA values.
  ...nokv Number of atomic non-NA values.
  ...neq Are ... arg lengths all the same?
  ...ndif Are ... arg lengths not all the same?
  ...minn .min ... arg length.
  ...maxn   .max ... arg length.

Functions evaluating length/count (in)equality

  ndif   Lengths of x and y are equal.
  neq Lengths of x and y are different.

Functions getting counts/lengths

  N length(x)
   
  ⁠nd, ndots⁠    ...length()
  ...n ...length()
   
  nc NCOL(x)
  nr NROW(x)
   
  ns lengths(x)
   
  ⁠nu, nunq⁠ length(unique(atoms(...)))
  ⁠nv, nval⁠ length(atoms(...))
  nw length(which(x))
   
  nrc NROW(x) * NCOL(x)
   
  nnav length(which(is.na(atoms(x))))
  nokv length(which(!is.na(atoms(x))))
  ndim f0(null(x), 0, f0(is_vec(x), 1, N(dim(x))))

Functions checking for specific counts/lengths

The functions described in the previous table also have convenience functions for checking for specific counts/lengths and for negation. Those convenience functions are formed by appending the following to function names:

  '0' N = 0
  '1' N = 1
  '2' N = 2
  '1p' ⁠N = 1+⁠
  '2p' ⁠N = 2+⁠
  '3p'   ⁠N = 3+⁠

The negation functions are formed by prepending not_. All convenience functions are given in the following table:

  Base   N = 0 N = 1 N = 2 ⁠N ≥ 1⁠ ⁠N ≥ 2⁠ ⁠N ≥ 3⁠
  N n0 n1 n2 n1p n2p n3p
  nd nd0 nd1 nd2 nd1p nd2p nd3p
  ...n ...n0 ...n1 ...n2 ...n1p ...n2p ...n3p
  nc nc0 nc1 nc2 nc1p nc2p nc3p
  nr nr0 nr1 nr2 nr1p nr2p nr3p
  ns ns0 ns1 ns2 ns1p ns2p ns3p
  nu nu0 nu1 nu2 nu1p nu2p nu3p
  nv nv0 nv1 nv2 nv1p nv2p nv3p
  nw nw0 nw1 nw2 nw1p nw2p nw3p
  nrc nrc0 nrc1 nrc2p
  ndim ndim0 ndim1 ndim2 ndim1p ndim2p ndim3p
              
  Base ⁠N ≠ 0⁠ ⁠N ≠ 1⁠ ⁠N ≠ 2⁠ N < 1 N < 2 N < 3
  not_n not_n0 not_n1 not_n2 not_n1p not_n2p not_n3p
  not_nd not_nd0 not_nd1 not_nd2 not_nd1p not_nd2p not_nd3p
  ...not_n ...not_n0 ...not_n1 ...not_n2 ...not_n1p ...not_n2p ...not_n3p
  not_nc not_nc0 not_nc1 not_nc2 not_nc1p not_nc2p not_nc3p
  not_nr not_nr0 not_nr1 not_nr2 not_nr1p not_nr2p not_nr3p
  not_ns not_ns0 not_ns1 not_ns2 not_ns1p not_ns2p not_ns3p
  not_nu not_nu0 not_nu1 not_nu2 not_nu1p not_nu2p not_nu3p
  not_nv not_nv0 not_nv1 not_nv2 not_nv1p not_nv2p not_nv3p
  not_nw not_nw0 not_nw1 not_nw2 not_nw1p not_nw2p not_nw3p
  not_nrc not_nrc0 not_nrc1 not_nrc2p
  not_ndim   not_ndim0  not_ndim1  not_ndim2  not_ndim1p  not_ndim2p  not_ndim3p
   nc = 0 nc = 1 nc = 2 nc = 3 ⁠nc ≥ 1⁠ ⁠nc ≥ 2⁠ ⁠nc ≥ 3⁠
  nr = 0   nr0_nc0 nr0_nc1 nr0_nc2 nr0_nc3 nr0_nc1p nr0_nc2p nr0_nc3p
  nr = 1 nr1_nc0 nr1_nc1 nr1_nc2 nr1_nc3 nr1_nc1p nr1_nc2p nr1_nc3p
  nr = 2 nr2_nc0 nr2_nc1 nr2_nc2 nr2_nc3 nr2_nc1p nr2_nc2p nr2_nc3p
  nr = 3 nr3_nc0 nr3_nc1 nr3_nc2 nr3_nc3 nr3_nc1p nr3_nc2p nr3_nc3p
  ⁠nr ≥ 1⁠ nr1_pnc0 nr1p_nc1 nr1p_nc2 nr1p_nc3 nr1p_nc1p nr1p_nc2p nr1p_nc3p
  ⁠nr ≥ 2⁠ nr2p_nc0 nr2p_nc1 nr2p_nc2 nr2p_nc3 nr2p_nc1p nr2p_nc2p nr2p_nc3p
  ⁠nr ≥ 3⁠ nr3p_nc0  nr3p_nc1  nr3p_nc2  nr3p_nc3  nr3p_nc1p  nr3p_nc2p  nr3p_nc3p
                
   ⁠nc ≠ 0⁠ ⁠nc ≠ 1⁠ ⁠nc ≠ 3⁠ ⁠nc ≠ 2⁠ nc < 1 nc < 2 nc < 3
  ⁠nr ≠ 0⁠   not_nr0_nc0 not_nr0_nc1 not_nr0_nc3 not_nr0_nc2 not_nr0_nc1p not_nr0_nc2p not_nr0_nc3p
  ⁠nr ≠ 1⁠ not_nr1_nc0 not_nr1_nc1 not_nr1_nc3 not_nr1_nc2 not_nr1_nc1p not_nr1_nc2p not_nr1_nc3p
  ⁠nr ≠ 2⁠ not_nr2_nc0 not_nr2_nc1 not_nr2_nc3 not_nr2_nc2 not_nr2_nc1p not_nr2_nc2p not_nr2_nc3p
  ⁠nr ≠ 3⁠ not_nr2_nc0 not_nr2_nc1 not_nr2_nc3 not_nr2_nc2 not_nr2_nc1p not_nr2_nc2p not_nr2_nc3p
  nr < 1 not_nr1p_nc0 not_nr1p_nc1 not_nr1p_nc3 not_nr1p_nc2 not_nr1p_nc1p not_nr1p_nc2p not_nr1p_nc3p
  nr < 2 not_nr2p_nc0 not_nr2p_nc1 not_nr2p_nc3 not_nr2p_nc2 not_nr2p_nc1p not_nr2p_nc2p not_nr2p_nc3p
  nr < 3 not_nr3p_nc0  not_nr3p_nc1  not_nr3p_nc3  not_nr3p_nc2  not_nr3p_nc1p  not_nr3p_nc2p  not_nr3p_nc3p

Value

May be non-negative integer or a logical scalar or vector, depending the properties of primary argument(s) (i.e., x and ...) and optional arguments (i.e., all others).

See Also

Other counts: maxnch()

Examples


##
## DEFINE INITIAL VARIABLE SET
##

vAa <- c(letters, LETTERS)
va <- letters
vA <- LETTERS

l0s <- c(0, 0, 0)
l0 <- NULL
l1 <- 0
l2 <- 0:1
l3 <- 0:2
l4 <- 0:3
l10 <- 0:9
l100 <- 0:99
l1000 <- sample(0:10, 1000, replace = T)

vList <- list(l0 = l0, l1 = l1, l2 = l2, va = va, vAa = vAa)

##
## DEMO [n_check] FUNCTION
##

n_check(length(va), .n = 26)
n_check(length(vA), .n = 52)
n_check(length(vAa), .n = 26:52)

n_check(l10, .min = 5, .max = 10)
n_check(l10, .min = 11, .max = 11)

n_check(l10, .eq = T)
n_check(l0s, .eq = T)

##
## DEMO [nX], [nXp], [not_nX] AND [not_nXp] FUNCTIONS
##

c(n0(l0), n0(l0s))
c(n1(l1), n1(l0))
c(n2(l1), n2(l2))
c(n3(l2), n3(l3))

c(n1p(l0), n1p(l1), n1p(l2))
c(n2p(l1), n2p(l2), n2p(l3))
c(n3p(l2), n3p(l3), n3p(l10))

c(not_n0(l0), n0(l0s))
c(not_n1(l1), n1(l0))
c(not_n2(l1), n2(l2))
c(not_n3(l2), n3(l3))

c(not_n1p(l0), not_n1p(l1), not_n1p(l2))
c(not_n2p(l1), not_n2p(l2), not_n2p(l3))
c(not_n3p(l2), not_n3p(l3), not_n3p(l10))

## DEMO [ndX], [ndXp], [not_ndX], and [not_ndXp] FUNCTIONS

c(nd0(), nd0(l0), nd0(l0, l1))
c(nd1(), nd1(l0), nd1(l0, l1))
c(nd2(l1), nd2(l1, l2), nd2(l1, l2, l3))
c(nd3(l1, l2), nd3(l1, l2, l3), nd3(l1, l2, l3, l4))

c(nd1p(), nd1p(l0), nd1p(l0, l1))
c(nd2p(l1), nd2p(l1, v2), nd2p(l1, l2, l3))
c(nd3p(l1, l2), nd3p(l1, l2, l3), nd3p(l1, l2, l3, l4))

c(not_nd0(), not_nd0(l0), not_nd0(l0, l1))
c(not_nd1(), not_nd1(l0), not_nd1(l0, l1))
c(not_nd2(l1), not_nd2(l1, l2), not_nd2(l1, l2, l3))
c(not_nd3(l1, l2), not_nd3(l1, l2, l3), not_nd3(l1, l2, l3, l4))

c(not_nd1p(), not_nd1p(l0), not_nd1p(l0, l1))
c(not_nd2p(l1), not_nd2p(l1, l2), not_nd2p(l1, l2, l3))
c(not_nd3p(l1, l2), not_nd3p(l1, l2, l3), not_nd3p(l1, l2, l3, l4))

##
## DEMO [nu], [nuX], [nuXp], [not_nuX], AND [not_nuXp] FUNCTIONS
##

c(nu(va), nu(vA), nu(vAa), nu(l0), nu(l10), nu(l100), nu(l1000))

c(nu0(l0), nu0(l1000))
c(nu1(l0), nu1(l1), nu2(l2))
c(nu2(l1), nu2(l2), nu2(l3))
c(nu3(l2), nu3(l3), nu3(l4))

c(nu1p(l0), nu1p(l1), nu2p(l2))
c(nu2p(l1), nu2p(l2), nu2p(l3))
c(nu3p(l2), nu3p(l3), nu3p(l4))

c(not_nu0(l0), not_nu0(l1000))
c(not_nu1(l0), not_nu1(l1), not_nu2(l2))
c(not_nu2(l1), not_nu2(l2), not_nu2(l3))
c(not_nu3(l2), not_nu3(l3), not_nu3(l4))

c(not_nu1p(l0), not_nu1p(l1), not_nu2p(l2))
c(not_nu2p(l1), not_nu2p(l2), not_nu2p(l3))
c(not_nu3p(l2), not_nu3p(l3), not_nu3p(l4))

##
## DEMO [nv], [nvX], [nvXp], [not_nvX], AND, [not_nvXp] FUNCTIONS
##

c(nv(l1000), nv(va), nv(vList))

c(nv0(l0), nv0(l0s))
c(nv1(l1), nv1(l0))
c(nv2(l1), nv2(l2))
c(nv3(l2), nv3(l3))

c(nv1p(l0), nv1p(l1), nv1p(l2))
c(nv2p(l1), nv2p(l2), nv2p(l3))
c(nv3p(l2), nv3p(l3), nv3p(l10))

c(not_nv0(l0), nv0(l0s))
c(not_nv1(l1), nv1(l0))
c(not_nv2(l1), nv2(l2))
c(not_nv3(l2), nv3(l3))

c(not_nv1p(l0), not_nv1p(l1), not_nv1p(l2))
c(not_nv2p(l1), not_nv2p(l2), not_nv2p(l3))
c(not_nv3p(l2), not_nv3p(l3), not_nv3p(l10))

##
## DEFINE TRUE/FALSE VARIABLE SET
##

vTF0 <- c()
vTF1 <- c(T, F)
vTF2 <- c(T, T, F, F)
vTF3 <- c(T, T, T, F, F, F)
vTF4 <- c(T, T, T, T, F, F, F, F)
vTFx <- sample(vTF1, 1000, replace = T)

##
## DEMO [nw], [nwX], [nwXp], [not_nwX], AND [not_nwXp] FUNCTIONS
##

c(nw(vTF1), nw(vTF2), nv(vTFx))

c(nw0(vTF0), nw0(vTF1))
c(nw1(vTF0), nw1(vTF1), nw1(vTF2))
c(nw2(vTF1), nw2(vTF2), nw2(vTF3))
c(nw3(vTF2), nw3(vTF3), nw3(vTF4))

c(nw1p(vTF0), nw1p(vTF1), nw1p(vTF2))
c(nw2p(vTF1), nw2p(vTF2), nw2p(vTF3))
c(nw3p(vTF2), nw3p(vTF3), nw3p(vTF4))

c(not_nw0(vTF0), not_nw0(vTF1))
c(not_nw1(vTF0), not_nw1(vTF1), not_nw1(vTF2))
c(not_nw2(vTF1), not_nw2(vTF2), not_nw2(vTF3))
c(not_nw3(vTF2), not_nw3(vTF3), not_nw3(vTF4))

c(not_nw1p(vTF0), not_nw1p(vTF1), not_nw1p(vTF2))
c(not_nw2p(vTF1), not_nw2p(vTF2), not_nw2p(vTF3))
c(not_nw3p(vTF2), not_nw3p(vTF3), not_nw3p(vTF4))

c(neq(l3, l3), neq(l3, l0s), neq(l1, l2))
c(ndif(l3, l3), ndif(l3, l0s), ndif(l1, l2))

##
## DEFINE MATRIX VARIABLE SET
##

m <- function(R, C) {matrix(1, nrow = R, ncol = C)}

m00 <- m(0, 0); m01 <- m(0, 1); m02 <- m(0, 2); m03 <- m(0, 3); m04 <- m(0, 4)
m10 <- m(1, 0); m11 <- m(1, 1); m12 <- m(1, 2); m13 <- m(1, 3); m14 <- m(1, 4)
m20 <- m(2, 0); m21 <- m(2, 1); m22 <- m(2, 2); m23 <- m(2, 3); m24 <- m(2, 4)
m30 <- m(3, 0); m31 <- m(3, 1); m32 <- m(3, 2); m33 <- m(3, 3); m34 <- m(3, 4)
m40 <- m(4, 0); m41 <- m(4, 1); m42 <- m(4, 2); m43 <- m(4, 3); m44 <- m(4, 4)

##
## DEMO [nr], [nc], AND [nrc] FUNCTIONS
##

c(nr(m00), nr(m10), nr(m20), nr(m30), nr(m40))
c(nc(m00), nc(m01), nc(m02), nc(m03), nc(m04))
c(nrc(m00), nrc(m11), nrc(m22), nrc(m33), nrc(m44))

##
## DEMO [ncX], [ncXp], [not_ncX], AND [not_ncXp] FUNCTIONS
##

c(nc0(m00), nc0(m01))
c(nc1(m00), nc1(m01), nc1(m02))
c(nc2(m01), nc2(m02), nc2(m03))
c(nc3(m02), nc3(m03), nc3(m04))

c(nc1p(m00), nc1p(m01), nc1p(m02))
c(nc2p(m01), nc2p(m02), nc2p(m03))
c(nc3p(m02), nc3p(m03), nc3p(m04))

c(not_nc0(m00), not_nc0(m01))
c(not_nc1(m00), not_nc1(m01), not_nc1(m02))
c(not_nc2(m01), not_nc2(m02), not_nc2(m03))
c(not_nc3(m02), not_nc3(m03), not_nc3(m04))

c(not_nc1p(m00), not_nc1p(m01), not_nc1p(m02))
c(not_nc2p(m01), not_nc2p(m02), not_nc2p(m03))
c(not_nc3p(m02), not_nc3p(m03), not_nc3p(m04))

##
## DEMO [nrX], [nrXp], [not_nrX], AND [not_nrXp] FUNCTIONS
##

c(nr0(m00), nr0(m10))
c(nr1(m00), nr1(m10), nr1(m20))
c(nr2(m10), nr2(m20), nr2(m30))
c(nr3(m20), nr3(m30), nr3(m40))

c(nr1p(m00), nr1p(m10), nr1p(m20))
c(nr2p(m10), nr2p(m20), nr2p(m30))
c(nr3p(m20), nr3p(m30), nr3p(m40))

c(not_nr0(m00), not_nr0(m10))
c(not_nr1(m00), not_nr1(m10), not_nr1(m20))
c(not_nr2(m10), not_nr2(m20), not_nr2(m30))
c(not_nr3(m20), not_nr3(m30), not_nr3(m40))

c(not_nr1p(m00), not_nr1p(m10), not_nr1p(m20))
c(not_nr2p(m10), not_nr2p(m20), not_nr2p(m30))
c(not_nr3p(m20), not_nr3p(m30), not_nr3p(m40))

##
## DEMO [nrcX], [nrcXp], [not_nrcX], AND [not_nrcXp] FUNCTIONS
##

c(nrc0(m00), nrc0(m01), nrc0(m10), nrc0(m11))
c(nrc1(m00), nrc1(m10), nrc1(m11), nrc1(m21))
c(nrc2(m11), nrc2(m12), nrc2(m21), nrc2(m22))

c(nrc1p(m00), nrc1p(m10), nrc1p(m11), nrc1p(m21))
c(nrc2p(m11), nrc2p(m12), nrc2p(m21), nrc2p(m22))

c(nr0_nc0(m00), nr0_nc0(m01), nr0_nc0(m02), nr0_nc0(m03), nr0_nc0(m04))
c(nr0_nc0(m10), nr0_nc0(m11), nr0_nc0(m12), nr0_nc0(m13), nr0_nc0(m14))
c(nr0_nc0(m20), nr0_nc0(m21), nr0_nc0(m22), nr0_nc0(m23), nr0_nc0(m24))
c(nr0_nc0(m30), nr0_nc0(m31), nr0_nc0(m32), nr0_nc0(m33), nr0_nc0(m34))
c(nr0_nc0(m40), nr0_nc0(m41), nr0_nc0(m42), nr0_nc0(m43), nr0_nc0(m44))

c(nr0_nc1(m00), nr0_nc1(m01), nr0_nc1(m02), nr0_nc1(m03), nr0_nc1(m04))
c(nr0_nc1(m10), nr0_nc1(m11), nr0_nc1(m12), nr0_nc1(m13), nr0_nc1(m14))
c(nr0_nc1(m20), nr0_nc1(m21), nr0_nc1(m22), nr0_nc1(m23), nr0_nc1(m24))
c(nr0_nc1(m30), nr0_nc1(m31), nr0_nc1(m32), nr0_nc1(m33), nr0_nc1(m34))
c(nr0_nc1(m40), nr0_nc1(m41), nr0_nc1(m42), nr0_nc1(m43), nr0_nc1(m44))

c(nr0_nc2(m00), nr0_nc2(m01), nr0_nc2(m02), nr0_nc2(m03), nr0_nc2(m04))
c(nr0_nc2(m10), nr0_nc2(m11), nr0_nc2(m12), nr0_nc2(m13), nr0_nc2(m14))
c(nr0_nc2(m20), nr0_nc2(m21), nr0_nc2(m22), nr0_nc2(m23), nr0_nc2(m24))
c(nr0_nc2(m30), nr0_nc2(m31), nr0_nc2(m32), nr0_nc2(m33), nr0_nc2(m34))
c(nr0_nc2(m40), nr0_nc2(m41), nr0_nc2(m42), nr0_nc2(m43), nr0_nc2(m44))

c(nr0_nc3(m00), nr0_nc3(m01), nr0_nc3(m02), nr0_nc3(m03), nr0_nc3(m04))
c(nr0_nc3(m10), nr0_nc3(m11), nr0_nc3(m12), nr0_nc3(m13), nr0_nc3(m14))
c(nr0_nc3(m20), nr0_nc3(m21), nr0_nc3(m22), nr0_nc3(m23), nr0_nc3(m24))
c(nr0_nc3(m30), nr0_nc3(m31), nr0_nc3(m32), nr0_nc3(m33), nr0_nc3(m34))
c(nr0_nc3(m40), nr0_nc3(m41), nr0_nc3(m42), nr0_nc3(m43), nr0_nc3(m44))

c(nr1_nc0(m00), nr1_nc0(m01), nr1_nc0(m02), nr1_nc0(m03), nr1_nc0(m04))
c(nr1_nc0(m10), nr1_nc0(m11), nr1_nc0(m12), nr1_nc0(m13), nr1_nc0(m14))
c(nr1_nc0(m20), nr1_nc0(m21), nr1_nc0(m22), nr1_nc0(m23), nr1_nc0(m24))
c(nr1_nc0(m30), nr1_nc0(m31), nr1_nc0(m32), nr1_nc0(m33), nr1_nc0(m34))
c(nr1_nc0(m40), nr1_nc0(m41), nr1_nc0(m42), nr1_nc0(m43), nr1_nc0(m44))

c(nr2_nc0(m00), nr2_nc0(m01), nr2_nc0(m02), nr2_nc0(m03), nr2_nc0(m04))
c(nr2_nc0(m10), nr2_nc0(m11), nr2_nc0(m12), nr2_nc0(m13), nr2_nc0(m14))
c(nr2_nc0(m20), nr2_nc0(m21), nr2_nc0(m22), nr2_nc0(m23), nr2_nc0(m24))
c(nr2_nc0(m30), nr2_nc0(m31), nr2_nc0(m32), nr2_nc0(m33), nr2_nc0(m34))
c(nr2_nc0(m40), nr2_nc0(m41), nr2_nc0(m42), nr2_nc0(m43), nr2_nc0(m44))

c(nr3_nc0(m00), nr3_nc0(m01), nr3_nc0(m02), nr3_nc0(m03), nr3_nc0(m04))
c(nr3_nc0(m10), nr3_nc0(m11), nr3_nc0(m12), nr3_nc0(m13), nr3_nc0(m14))
c(nr3_nc0(m20), nr3_nc0(m21), nr3_nc0(m22), nr3_nc0(m23), nr3_nc0(m24))
c(nr3_nc0(m30), nr3_nc0(m31), nr3_nc0(m32), nr3_nc0(m33), nr3_nc0(m34))
c(nr3_nc0(m40), nr3_nc0(m41), nr3_nc0(m42), nr3_nc0(m43), nr3_nc0(m44))

c(nr1_nc1(m00), nr1_nc1(m01), nr1_nc1(m02), nr1_nc1(m03), nr1_nc1(m04))
c(nr1_nc1(m10), nr1_nc1(m11), nr1_nc1(m12), nr1_nc1(m13), nr1_nc1(m14))
c(nr1_nc1(m20), nr1_nc1(m21), nr1_nc1(m22), nr1_nc1(m23), nr1_nc1(m24))
c(nr1_nc1(m30), nr1_nc1(m31), nr1_nc1(m32), nr1_nc1(m33), nr1_nc1(m34))
c(nr1_nc1(m40), nr1_nc1(m41), nr1_nc1(m42), nr1_nc1(m43), nr1_nc1(m44))

c(nr1_nc2(m00), nr1_nc2(m01), nr1_nc2(m02), nr1_nc2(m03), nr1_nc2(m04))
c(nr1_nc2(m10), nr1_nc2(m11), nr1_nc2(m12), nr1_nc2(m13), nr1_nc2(m14))
c(nr1_nc2(m20), nr1_nc2(m21), nr1_nc2(m22), nr1_nc2(m23), nr1_nc2(m24))
c(nr1_nc2(m30), nr1_nc2(m31), nr1_nc2(m32), nr1_nc2(m33), nr1_nc2(m34))
c(nr1_nc2(m40), nr1_nc2(m41), nr1_nc2(m42), nr1_nc2(m43), nr1_nc2(m44))

c(nr1_nc3(m00), nr1_nc3(m01), nr1_nc3(m02), nr1_nc3(m03), nr1_nc3(m04))
c(nr1_nc3(m10), nr1_nc3(m11), nr1_nc3(m12), nr1_nc3(m13), nr1_nc3(m14))
c(nr1_nc3(m20), nr1_nc3(m21), nr1_nc3(m22), nr1_nc3(m23), nr1_nc3(m24))
c(nr1_nc3(m30), nr1_nc3(m31), nr1_nc3(m32), nr1_nc3(m33), nr1_nc3(m34))
c(nr1_nc3(m40), nr1_nc3(m41), nr1_nc3(m42), nr1_nc3(m43), nr1_nc3(m44))

c(nr2_nc1(m00), nr2_nc1(m01), nr2_nc1(m02), nr2_nc1(m03), nr2_nc1(m04))
c(nr2_nc1(m10), nr2_nc1(m11), nr2_nc1(m12), nr2_nc1(m13), nr2_nc1(m14))
c(nr2_nc1(m20), nr2_nc1(m21), nr2_nc1(m22), nr2_nc1(m23), nr2_nc1(m24))
c(nr2_nc1(m30), nr2_nc1(m31), nr2_nc1(m32), nr2_nc1(m33), nr2_nc1(m34))
c(nr2_nc1(m40), nr2_nc1(m41), nr2_nc1(m42), nr2_nc1(m43), nr2_nc1(m44))

c(nr2_nc2(m00), nr2_nc2(m01), nr2_nc2(m02), nr2_nc2(m03), nr2_nc2(m04))
c(nr2_nc2(m10), nr2_nc2(m11), nr2_nc2(m12), nr2_nc2(m13), nr2_nc2(m14))
c(nr2_nc2(m20), nr2_nc2(m21), nr2_nc2(m22), nr2_nc2(m23), nr2_nc2(m24))
c(nr2_nc2(m30), nr2_nc2(m31), nr2_nc2(m32), nr2_nc2(m33), nr2_nc2(m34))
c(nr2_nc2(m40), nr2_nc2(m41), nr2_nc2(m42), nr2_nc2(m43), nr2_nc2(m44))

c(nr2_nc3(m00), nr2_nc3(m01), nr2_nc3(m02), nr2_nc3(m03), nr2_nc3(m04))
c(nr2_nc3(m10), nr2_nc3(m11), nr2_nc3(m12), nr2_nc3(m13), nr2_nc3(m14))
c(nr2_nc3(m20), nr2_nc3(m21), nr2_nc3(m22), nr2_nc3(m23), nr2_nc3(m24))
c(nr2_nc3(m30), nr2_nc3(m31), nr2_nc3(m32), nr2_nc3(m33), nr2_nc3(m34))
c(nr2_nc3(m40), nr2_nc3(m41), nr2_nc3(m42), nr2_nc3(m43), nr2_nc3(m44))

c(nr3_nc1(m00), nr3_nc1(m01), nr3_nc1(m02), nr3_nc1(m03), nr3_nc1(m04))
c(nr3_nc1(m10), nr3_nc1(m11), nr3_nc1(m12), nr3_nc1(m13), nr3_nc1(m14))
c(nr3_nc1(m20), nr3_nc1(m21), nr3_nc1(m22), nr3_nc1(m23), nr3_nc1(m24))
c(nr3_nc1(m30), nr3_nc1(m31), nr3_nc1(m32), nr3_nc1(m33), nr3_nc1(m34))
c(nr3_nc1(m40), nr3_nc1(m41), nr3_nc1(m42), nr3_nc1(m43), nr3_nc1(m44))

c(nr3_nc2(m00), nr3_nc2(m01), nr3_nc2(m02), nr3_nc2(m03), nr3_nc2(m04))
c(nr3_nc2(m10), nr3_nc2(m11), nr3_nc2(m12), nr3_nc2(m13), nr3_nc2(m14))
c(nr3_nc2(m20), nr3_nc2(m21), nr3_nc2(m22), nr3_nc2(m23), nr3_nc2(m24))
c(nr3_nc2(m30), nr3_nc2(m31), nr3_nc2(m32), nr3_nc2(m33), nr3_nc2(m34))
c(nr3_nc2(m40), nr3_nc2(m41), nr3_nc2(m42), nr3_nc2(m43), nr3_nc2(m44))

c(nr3_nc3(m00), nr3_nc3(m01), nr3_nc3(m02), nr3_nc3(m03), nr3_nc3(m04))
c(nr3_nc3(m10), nr3_nc3(m11), nr3_nc3(m12), nr3_nc3(m13), nr3_nc3(m14))
c(nr3_nc3(m20), nr3_nc3(m21), nr3_nc3(m22), nr3_nc3(m23), nr3_nc3(m24))
c(nr3_nc3(m30), nr3_nc3(m31), nr3_nc3(m32), nr3_nc3(m33), nr3_nc3(m34))
c(nr3_nc3(m40), nr3_nc3(m41), nr3_nc3(m42), nr3_nc3(m43), nr3_nc3(m44))

c(nr0_nc1p(m00), nr0_nc1p(m01), nr0_nc1p(m02), nr0_nc1p(m03), nr0_nc1p(m04))
c(nr0_nc1p(m10), nr0_nc1p(m11), nr0_nc1p(m12), nr0_nc1p(m13), nr0_nc1p(m14))
c(nr0_nc1p(m20), nr0_nc1p(m21), nr0_nc1p(m22), nr0_nc1p(m23), nr0_nc1p(m24))
c(nr0_nc1p(m30), nr0_nc1p(m31), nr0_nc1p(m32), nr0_nc1p(m33), nr0_nc1p(m34))
c(nr0_nc1p(m40), nr0_nc1p(m41), nr0_nc1p(m42), nr0_nc1p(m43), nr0_nc1p(m44))

c(nr0_nc2p(m00), nr0_nc2p(m01), nr0_nc2p(m02), nr0_nc2p(m03), nr0_nc2p(m04))
c(nr0_nc2p(m10), nr0_nc2p(m11), nr0_nc2p(m12), nr0_nc2p(m13), nr0_nc2p(m14))
c(nr0_nc2p(m20), nr0_nc2p(m21), nr0_nc2p(m22), nr0_nc2p(m23), nr0_nc2p(m24))
c(nr0_nc2p(m30), nr0_nc2p(m31), nr0_nc2p(m32), nr0_nc2p(m33), nr0_nc2p(m34))
c(nr0_nc2p(m40), nr0_nc2p(m41), nr0_nc2p(m42), nr0_nc2p(m43), nr0_nc2p(m44))

c(nr0_nc3p(m00), nr0_nc3p(m01), nr0_nc3p(m02), nr0_nc3p(m03), nr0_nc3p(m04))
c(nr0_nc3p(m10), nr0_nc3p(m11), nr0_nc3p(m12), nr0_nc3p(m13), nr0_nc3p(m14))
c(nr0_nc3p(m20), nr0_nc3p(m21), nr0_nc3p(m22), nr0_nc3p(m23), nr0_nc3p(m24))
c(nr0_nc3p(m30), nr0_nc3p(m31), nr0_nc3p(m32), nr0_nc3p(m33), nr0_nc3p(m34))
c(nr0_nc3p(m40), nr0_nc3p(m41), nr0_nc3p(m42), nr0_nc3p(m43), nr0_nc3p(m44))

c(nr1p_nc0(m00), nr1p_nc0(m01), nr1p_nc0(m02), nr1p_nc0(m03), nr1p_nc0(m04))
c(nr1p_nc0(m10), nr1p_nc0(m11), nr1p_nc0(m12), nr1p_nc0(m13), nr1p_nc0(m14))
c(nr1p_nc0(m20), nr1p_nc0(m21), nr1p_nc0(m22), nr1p_nc0(m23), nr1p_nc0(m24))
c(nr1p_nc0(m30), nr1p_nc0(m31), nr1p_nc0(m32), nr1p_nc0(m33), nr1p_nc0(m34))
c(nr1p_nc0(m40), nr1p_nc0(m41), nr1p_nc0(m42), nr1p_nc0(m43), nr1p_nc0(m44))

c(nr2p_nc0(m00), nr2p_nc0(m01), nr2p_nc0(m02), nr2p_nc0(m03), nr2p_nc0(m04))
c(nr2p_nc0(m10), nr2p_nc0(m11), nr2p_nc0(m12), nr2p_nc0(m13), nr2p_nc0(m14))
c(nr2p_nc0(m20), nr2p_nc0(m21), nr2p_nc0(m22), nr2p_nc0(m23), nr2p_nc0(m24))
c(nr2p_nc0(m30), nr2p_nc0(m31), nr2p_nc0(m32), nr2p_nc0(m33), nr2p_nc0(m34))
c(nr2p_nc0(m40), nr2p_nc0(m41), nr2p_nc0(m42), nr2p_nc0(m43), nr2p_nc0(m44))

c(nr3p_nc0(m00), nr3p_nc0(m01), nr3p_nc0(m02), nr3p_nc0(m03), nr3p_nc0(m04))
c(nr3p_nc0(m10), nr3p_nc0(m11), nr3p_nc0(m12), nr3p_nc0(m13), nr3p_nc0(m14))
c(nr3p_nc0(m20), nr3p_nc0(m21), nr3p_nc0(m22), nr3p_nc0(m23), nr3p_nc0(m24))
c(nr3p_nc0(m30), nr3p_nc0(m31), nr3p_nc0(m32), nr3p_nc0(m33), nr3p_nc0(m34))
c(nr3p_nc0(m40), nr3p_nc0(m41), nr3p_nc0(m42), nr3p_nc0(m43), nr3p_nc0(m44))

c(nr1p_nc1p(m00), nr1p_nc1p(m01), nr1p_nc1p(m02), nr1p_nc1p(m03), nr1p_nc1p(m04))
c(nr1p_nc1p(m10), nr1p_nc1p(m11), nr1p_nc1p(m12), nr1p_nc1p(m13), nr1p_nc1p(m14))
c(nr1p_nc1p(m20), nr1p_nc1p(m21), nr1p_nc1p(m22), nr1p_nc1p(m23), nr1p_nc1p(m24))
c(nr1p_nc1p(m30), nr1p_nc1p(m31), nr1p_nc1p(m32), nr1p_nc1p(m33), nr1p_nc1p(m34))
c(nr1p_nc1p(m40), nr1p_nc1p(m41), nr1p_nc1p(m42), nr1p_nc1p(m43), nr1p_nc1p(m44))

c(nr1p_nc2p(m00), nr1p_nc2p(m01), nr1p_nc2p(m02), nr1p_nc2p(m03), nr1p_nc2p(m04))
c(nr1p_nc2p(m10), nr1p_nc2p(m11), nr1p_nc2p(m12), nr1p_nc2p(m13), nr1p_nc2p(m14))
c(nr1p_nc2p(m20), nr1p_nc2p(m21), nr1p_nc2p(m22), nr1p_nc2p(m23), nr1p_nc2p(m24))
c(nr1p_nc2p(m30), nr1p_nc2p(m31), nr1p_nc2p(m32), nr1p_nc2p(m33), nr1p_nc2p(m34))
c(nr1p_nc2p(m40), nr1p_nc2p(m41), nr1p_nc2p(m42), nr1p_nc2p(m43), nr1p_nc2p(m44))

c(nr1p_nc3p(m00), nr1p_nc3p(m01), nr1p_nc3p(m02), nr1p_nc3p(m03), nr1p_nc3p(m04))
c(nr1p_nc3p(m10), nr1p_nc3p(m11), nr1p_nc3p(m12), nr1p_nc3p(m13), nr1p_nc3p(m14))
c(nr1p_nc3p(m20), nr1p_nc3p(m21), nr1p_nc3p(m22), nr1p_nc3p(m23), nr1p_nc3p(m24))
c(nr1p_nc3p(m30), nr1p_nc3p(m31), nr1p_nc3p(m32), nr1p_nc3p(m33), nr1p_nc3p(m34))
c(nr1p_nc3p(m40), nr1p_nc3p(m41), nr1p_nc3p(m42), nr1p_nc3p(m43), nr1p_nc3p(m44))

c(nr2p_nc1p(m00), nr2p_nc1p(m01), nr2p_nc1p(m02), nr2p_nc1p(m03), nr2p_nc1p(m04))
c(nr2p_nc1p(m10), nr2p_nc1p(m11), nr2p_nc1p(m12), nr2p_nc1p(m13), nr2p_nc1p(m14))
c(nr2p_nc1p(m20), nr2p_nc1p(m21), nr2p_nc1p(m22), nr2p_nc1p(m23), nr2p_nc1p(m24))
c(nr2p_nc1p(m30), nr2p_nc1p(m31), nr2p_nc1p(m32), nr2p_nc1p(m33), nr2p_nc1p(m34))
c(nr2p_nc1p(m40), nr2p_nc1p(m41), nr2p_nc1p(m42), nr2p_nc1p(m43), nr2p_nc1p(m44))

c(nr2p_nc2p(m00), nr2p_nc2p(m01), nr2p_nc2p(m02), nr2p_nc2p(m03), nr2p_nc2p(m04))
c(nr2p_nc2p(m10), nr2p_nc2p(m11), nr2p_nc2p(m12), nr2p_nc2p(m13), nr2p_nc2p(m14))
c(nr2p_nc2p(m20), nr2p_nc2p(m21), nr2p_nc2p(m22), nr2p_nc2p(m23), nr2p_nc2p(m24))
c(nr2p_nc2p(m30), nr2p_nc2p(m31), nr2p_nc2p(m32), nr2p_nc2p(m33), nr2p_nc2p(m34))
c(nr2p_nc2p(m40), nr2p_nc2p(m41), nr2p_nc2p(m42), nr2p_nc2p(m43), nr2p_nc2p(m44))

c(nr2p_nc3p(m00), nr2p_nc3p(m01), nr2p_nc3p(m02), nr2p_nc3p(m03), nr2p_nc3p(m04))
c(nr2p_nc3p(m10), nr2p_nc3p(m11), nr2p_nc3p(m12), nr2p_nc3p(m13), nr2p_nc3p(m14))
c(nr2p_nc3p(m20), nr2p_nc3p(m21), nr2p_nc3p(m22), nr2p_nc3p(m23), nr2p_nc3p(m24))
c(nr2p_nc3p(m30), nr2p_nc3p(m31), nr2p_nc3p(m32), nr2p_nc3p(m33), nr2p_nc3p(m34))
c(nr2p_nc3p(m40), nr2p_nc3p(m41), nr2p_nc3p(m42), nr2p_nc3p(m43), nr2p_nc3p(m44))

c(nr3p_nc1p(m00), nr3p_nc1p(m01), nr3p_nc1p(m02), nr3p_nc1p(m03), nr3p_nc1p(m04))
c(nr3p_nc1p(m10), nr3p_nc1p(m11), nr3p_nc1p(m12), nr3p_nc1p(m13), nr3p_nc1p(m14))
c(nr3p_nc1p(m20), nr3p_nc1p(m21), nr3p_nc1p(m22), nr3p_nc1p(m23), nr3p_nc1p(m24))
c(nr3p_nc1p(m30), nr3p_nc1p(m31), nr3p_nc1p(m32), nr3p_nc1p(m33), nr3p_nc1p(m34))
c(nr3p_nc1p(m40), nr3p_nc1p(m41), nr3p_nc1p(m42), nr3p_nc1p(m43), nr3p_nc1p(m44))

c(nr3p_nc2p(m00), nr3p_nc2p(m01), nr3p_nc2p(m02), nr3p_nc2p(m03), nr3p_nc2p(m04))
c(nr3p_nc2p(m10), nr3p_nc2p(m11), nr3p_nc2p(m12), nr3p_nc2p(m13), nr3p_nc2p(m14))
c(nr3p_nc2p(m20), nr3p_nc2p(m21), nr3p_nc2p(m22), nr3p_nc2p(m23), nr3p_nc2p(m24))
c(nr3p_nc2p(m30), nr3p_nc2p(m31), nr3p_nc2p(m32), nr3p_nc2p(m33), nr3p_nc2p(m34))
c(nr3p_nc2p(m40), nr3p_nc2p(m41), nr3p_nc2p(m42), nr3p_nc2p(m43), nr3p_nc2p(m44))

c(nr3p_nc3p(m00), nr3p_nc3p(m01), nr3p_nc3p(m02), nr3p_nc3p(m03), nr3p_nc3p(m04))
c(nr3p_nc3p(m10), nr3p_nc3p(m11), nr3p_nc3p(m12), nr3p_nc3p(m13), nr3p_nc3p(m14))
c(nr3p_nc3p(m20), nr3p_nc3p(m21), nr3p_nc3p(m22), nr3p_nc3p(m23), nr3p_nc3p(m24))
c(nr3p_nc3p(m30), nr3p_nc3p(m31), nr3p_nc3p(m32), nr3p_nc3p(m33), nr3p_nc3p(m34))
c(nr3p_nc3p(m40), nr3p_nc3p(m41), nr3p_nc3p(m42), nr3p_nc3p(m43), nr3p_nc3p(m44))

c(not_nr0_nc0(m00), not_nr0_nc0(m01), not_nr0_nc0(m02), not_nr0_nc0(m03), not_nr0_nc0(m04))
c(not_nr0_nc0(m10), not_nr0_nc0(m11), not_nr0_nc0(m12), not_nr0_nc0(m13), not_nr0_nc0(m14))
c(not_nr0_nc0(m20), not_nr0_nc0(m21), not_nr0_nc0(m22), not_nr0_nc0(m23), not_nr0_nc0(m24))
c(not_nr0_nc0(m30), not_nr0_nc0(m31), not_nr0_nc0(m32), not_nr0_nc0(m33), not_nr0_nc0(m34))
c(not_nr0_nc0(m40), not_nr0_nc0(m41), not_nr0_nc0(m42), not_nr0_nc0(m43), not_nr0_nc0(m44))

c(not_nr0_nc1(m00), not_nr0_nc1(m01), not_nr0_nc1(m02), not_nr0_nc1(m03), not_nr0_nc1(m04))
c(not_nr0_nc1(m10), not_nr0_nc1(m11), not_nr0_nc1(m12), not_nr0_nc1(m13), not_nr0_nc1(m14))
c(not_nr0_nc1(m20), not_nr0_nc1(m21), not_nr0_nc1(m22), not_nr0_nc1(m23), not_nr0_nc1(m24))
c(not_nr0_nc1(m30), not_nr0_nc1(m31), not_nr0_nc1(m32), not_nr0_nc1(m33), not_nr0_nc1(m34))
c(not_nr0_nc1(m40), not_nr0_nc1(m41), not_nr0_nc1(m42), not_nr0_nc1(m43), not_nr0_nc1(m44))

c(not_nr0_nc2(m00), not_nr0_nc2(m01), not_nr0_nc2(m02), not_nr0_nc2(m03), not_nr0_nc2(m04))
c(not_nr0_nc2(m10), not_nr0_nc2(m11), not_nr0_nc2(m12), not_nr0_nc2(m13), not_nr0_nc2(m14))
c(not_nr0_nc2(m20), not_nr0_nc2(m21), not_nr0_nc2(m22), not_nr0_nc2(m23), not_nr0_nc2(m24))
c(not_nr0_nc2(m30), not_nr0_nc2(m31), not_nr0_nc2(m32), not_nr0_nc2(m33), not_nr0_nc2(m34))
c(not_nr0_nc2(m40), not_nr0_nc2(m41), not_nr0_nc2(m42), not_nr0_nc2(m43), not_nr0_nc2(m44))

c(not_nr0_nc3(m00), not_nr0_nc3(m01), not_nr0_nc3(m02), not_nr0_nc3(m03), not_nr0_nc3(m04))
c(not_nr0_nc3(m10), not_nr0_nc3(m11), not_nr0_nc3(m12), not_nr0_nc3(m13), not_nr0_nc3(m14))
c(not_nr0_nc3(m20), not_nr0_nc3(m21), not_nr0_nc3(m22), not_nr0_nc3(m23), not_nr0_nc3(m24))
c(not_nr0_nc3(m30), not_nr0_nc3(m31), not_nr0_nc3(m32), not_nr0_nc3(m33), not_nr0_nc3(m34))
c(not_nr0_nc3(m40), not_nr0_nc3(m41), not_nr0_nc3(m42), not_nr0_nc3(m43), not_nr0_nc3(m44))

c(not_nr1_nc0(m00), not_nr1_nc0(m01), not_nr1_nc0(m02), not_nr1_nc0(m03), not_nr1_nc0(m04))
c(not_nr1_nc0(m10), not_nr1_nc0(m11), not_nr1_nc0(m12), not_nr1_nc0(m13), not_nr1_nc0(m14))
c(not_nr1_nc0(m20), not_nr1_nc0(m21), not_nr1_nc0(m22), not_nr1_nc0(m23), not_nr1_nc0(m24))
c(not_nr1_nc0(m30), not_nr1_nc0(m31), not_nr1_nc0(m32), not_nr1_nc0(m33), not_nr1_nc0(m34))
c(not_nr1_nc0(m40), not_nr1_nc0(m41), not_nr1_nc0(m42), not_nr1_nc0(m43), not_nr1_nc0(m44))

c(not_nr2_nc0(m00), not_nr2_nc0(m01), not_nr2_nc0(m02), not_nr2_nc0(m03), not_nr2_nc0(m04))
c(not_nr2_nc0(m10), not_nr2_nc0(m11), not_nr2_nc0(m12), not_nr2_nc0(m13), not_nr2_nc0(m14))
c(not_nr2_nc0(m20), not_nr2_nc0(m21), not_nr2_nc0(m22), not_nr2_nc0(m23), not_nr2_nc0(m24))
c(not_nr2_nc0(m30), not_nr2_nc0(m31), not_nr2_nc0(m32), not_nr2_nc0(m33), not_nr2_nc0(m34))
c(not_nr2_nc0(m40), not_nr2_nc0(m41), not_nr2_nc0(m42), not_nr2_nc0(m43), not_nr2_nc0(m44))

c(not_nr3_nc0(m00), not_nr3_nc0(m01), not_nr3_nc0(m02), not_nr3_nc0(m03), not_nr3_nc0(m04))
c(not_nr3_nc0(m10), not_nr3_nc0(m11), not_nr3_nc0(m12), not_nr3_nc0(m13), not_nr3_nc0(m14))
c(not_nr3_nc0(m20), not_nr3_nc0(m21), not_nr3_nc0(m22), not_nr3_nc0(m23), not_nr3_nc0(m24))
c(not_nr3_nc0(m30), not_nr3_nc0(m31), not_nr3_nc0(m32), not_nr3_nc0(m33), not_nr3_nc0(m34))
c(not_nr3_nc0(m40), not_nr3_nc0(m41), not_nr3_nc0(m42), not_nr3_nc0(m43), not_nr3_nc0(m44))

c(not_nr1_nc1(m00), not_nr1_nc1(m01), not_nr1_nc1(m02), not_nr1_nc1(m03), not_nr1_nc1(m04))
c(not_nr1_nc1(m10), not_nr1_nc1(m11), not_nr1_nc1(m12), not_nr1_nc1(m13), not_nr1_nc1(m14))
c(not_nr1_nc1(m20), not_nr1_nc1(m21), not_nr1_nc1(m22), not_nr1_nc1(m23), not_nr1_nc1(m24))
c(not_nr1_nc1(m30), not_nr1_nc1(m31), not_nr1_nc1(m32), not_nr1_nc1(m33), not_nr1_nc1(m34))
c(not_nr1_nc1(m40), not_nr1_nc1(m41), not_nr1_nc1(m42), not_nr1_nc1(m43), not_nr1_nc1(m44))

c(not_nr1_nc2(m00), not_nr1_nc2(m01), not_nr1_nc2(m02), not_nr1_nc2(m03), not_nr1_nc2(m04))
c(not_nr1_nc2(m10), not_nr1_nc2(m11), not_nr1_nc2(m12), not_nr1_nc2(m13), not_nr1_nc2(m14))
c(not_nr1_nc2(m20), not_nr1_nc2(m21), not_nr1_nc2(m22), not_nr1_nc2(m23), not_nr1_nc2(m24))
c(not_nr1_nc2(m30), not_nr1_nc2(m31), not_nr1_nc2(m32), not_nr1_nc2(m33), not_nr1_nc2(m34))
c(not_nr1_nc2(m40), not_nr1_nc2(m41), not_nr1_nc2(m42), not_nr1_nc2(m43), not_nr1_nc2(m44))

c(not_nr1_nc3(m00), not_nr1_nc3(m01), not_nr1_nc3(m02), not_nr1_nc3(m03), not_nr1_nc3(m04))
c(not_nr1_nc3(m10), not_nr1_nc3(m11), not_nr1_nc3(m12), not_nr1_nc3(m13), not_nr1_nc3(m14))
c(not_nr1_nc3(m20), not_nr1_nc3(m21), not_nr1_nc3(m22), not_nr1_nc3(m23), not_nr1_nc3(m24))
c(not_nr1_nc3(m30), not_nr1_nc3(m31), not_nr1_nc3(m32), not_nr1_nc3(m33), not_nr1_nc3(m34))
c(not_nr1_nc3(m40), not_nr1_nc3(m41), not_nr1_nc3(m42), not_nr1_nc3(m43), not_nr1_nc3(m44))

c(not_nr2_nc1(m00), not_nr2_nc1(m01), not_nr2_nc1(m02), not_nr2_nc1(m03), not_nr2_nc1(m04))
c(not_nr2_nc1(m10), not_nr2_nc1(m11), not_nr2_nc1(m12), not_nr2_nc1(m13), not_nr2_nc1(m14))
c(not_nr2_nc1(m20), not_nr2_nc1(m21), not_nr2_nc1(m22), not_nr2_nc1(m23), not_nr2_nc1(m24))
c(not_nr2_nc1(m30), not_nr2_nc1(m31), not_nr2_nc1(m32), not_nr2_nc1(m33), not_nr2_nc1(m34))
c(not_nr2_nc1(m40), not_nr2_nc1(m41), not_nr2_nc1(m42), not_nr2_nc1(m43), not_nr2_nc1(m44))

c(not_nr2_nc2(m00), not_nr2_nc2(m01), not_nr2_nc2(m02), not_nr2_nc2(m03), not_nr2_nc2(m04))
c(not_nr2_nc2(m10), not_nr2_nc2(m11), not_nr2_nc2(m12), not_nr2_nc2(m13), not_nr2_nc2(m14))
c(not_nr2_nc2(m20), not_nr2_nc2(m21), not_nr2_nc2(m22), not_nr2_nc2(m23), not_nr2_nc2(m24))
c(not_nr2_nc2(m30), not_nr2_nc2(m31), not_nr2_nc2(m32), not_nr2_nc2(m33), not_nr2_nc2(m34))
c(not_nr2_nc2(m40), not_nr2_nc2(m41), not_nr2_nc2(m42), not_nr2_nc2(m43), not_nr2_nc2(m44))

c(not_nr2_nc3(m00), not_nr2_nc3(m01), not_nr2_nc3(m02), not_nr2_nc3(m03), not_nr2_nc3(m04))
c(not_nr2_nc3(m10), not_nr2_nc3(m11), not_nr2_nc3(m12), not_nr2_nc3(m13), not_nr2_nc3(m14))
c(not_nr2_nc3(m20), not_nr2_nc3(m21), not_nr2_nc3(m22), not_nr2_nc3(m23), not_nr2_nc3(m24))
c(not_nr2_nc3(m30), not_nr2_nc3(m31), not_nr2_nc3(m32), not_nr2_nc3(m33), not_nr2_nc3(m34))
c(not_nr2_nc3(m40), not_nr2_nc3(m41), not_nr2_nc3(m42), not_nr2_nc3(m43), not_nr2_nc3(m44))

c(not_nr3_nc1(m00), not_nr3_nc1(m11), not_nr3_nc1(m12), not_nr3_nc1(m13), not_nr3_nc1(m14))
c(not_nr3_nc1(m20), not_nr3_nc1(m21), not_nr3_nc1(m22), not_nr3_nc1(m23), not_nr3_nc1(m24))
c(not_nr3_nc1(m30), not_nr3_nc1(m31), not_nr3_nc1(m32), not_nr3_nc1(m33), not_nr3_nc1(m34))
c(not_nr3_nc1(m40), not_nr3_nc1(m41), not_nr3_nc1(m42), not_nr3_nc1(m43), not_nr3_nc1(m44))
c(not_nr3_nc2(m00), not_nr3_nc2(m01), not_nr3_nc2(m02), not_nr3_nc2(m03), not_nr3_nc2(m04))
c(not_nr3_nc2(m10), not_nr3_nc2(m11), not_nr3_nc2(m12), not_nr3_nc2(m13), not_nr3_nc2(m14))
c(not_nr3_nc2(m20), not_nr3_nc2(m21), not_nr3_nc2(m22), not_nr3_nc2(m23), not_nr3_nc2(m24))
c(not_nr3_nc2(m30), not_nr3_nc2(m31), not_nr3_nc2(m32), not_nr3_nc2(m33), not_nr3_nc2(m34))
c(not_nr3_nc2(m40), not_nr3_nc2(m41), not_nr3_nc2(m42), not_nr3_nc2(m43), not_nr3_nc2(m44))

c(not_nr3_nc3(m00), not_nr3_nc3(m01), not_nr3_nc3(m02), not_nr3_nc3(m03), not_nr3_nc3(m04))
c(not_nr3_nc3(m10), not_nr3_nc3(m11), not_nr3_nc3(m12), not_nr3_nc3(m13), not_nr3_nc3(m14))
c(not_nr3_nc3(m20), not_nr3_nc3(m21), not_nr3_nc3(m22), not_nr3_nc3(m23), not_nr3_nc3(m24))
c(not_nr3_nc3(m30), not_nr3_nc3(m31), not_nr3_nc3(m32), not_nr3_nc3(m33), not_nr3_nc3(m34))
c(not_nr3_nc3(m40), not_nr3_nc3(m41), not_nr3_nc3(m42), not_nr3_nc3(m43), not_nr3_nc3(m44))

c(not_nr0_nc1p(m00), not_nr0_nc1p(m01), not_nr0_nc1p(m02), not_nr0_nc1p(m03), not_nr0_nc1p(m04))
c(not_nr0_nc1p(m10), not_nr0_nc1p(m11), not_nr0_nc1p(m12), not_nr0_nc1p(m13), not_nr0_nc1p(m14))
c(not_nr0_nc1p(m20), not_nr0_nc1p(m21), not_nr0_nc1p(m22), not_nr0_nc1p(m23), not_nr0_nc1p(m24))
c(not_nr0_nc1p(m30), not_nr0_nc1p(m31), not_nr0_nc1p(m32), not_nr0_nc1p(m33), not_nr0_nc1p(m34))
c(not_nr0_nc1p(m40), not_nr0_nc1p(m41), not_nr0_nc1p(m42), not_nr0_nc1p(m43), not_nr0_nc1p(m44))

c(not_nr0_nc2p(m00), not_nr0_nc2p(m01), not_nr0_nc2p(m02), not_nr0_nc2p(m03), not_nr0_nc2p(m04))
c(not_nr0_nc2p(m10), not_nr0_nc2p(m11), not_nr0_nc2p(m12), not_nr0_nc2p(m13), not_nr0_nc2p(m14))
c(not_nr0_nc2p(m20), not_nr0_nc2p(m21), not_nr0_nc2p(m22), not_nr0_nc2p(m23), not_nr0_nc2p(m24))
c(not_nr0_nc2p(m30), not_nr0_nc2p(m31), not_nr0_nc2p(m32), not_nr0_nc2p(m33), not_nr0_nc2p(m34))
c(not_nr0_nc2p(m40), not_nr0_nc2p(m41), not_nr0_nc2p(m42), not_nr0_nc2p(m43), not_nr0_nc2p(m44))

c(not_nr0_nc3p(m00), not_nr0_nc3p(m01), not_nr0_nc3p(m02), not_nr0_nc3p(m03), not_nr0_nc3p(m04))
c(not_nr0_nc3p(m10), not_nr0_nc3p(m11), not_nr0_nc3p(m12), not_nr0_nc3p(m13), not_nr0_nc3p(m14))
c(not_nr0_nc3p(m20), not_nr0_nc3p(m21), not_nr0_nc3p(m22), not_nr0_nc3p(m23), not_nr0_nc3p(m24))
c(not_nr0_nc3p(m30), not_nr0_nc3p(m31), not_nr0_nc3p(m32), not_nr0_nc3p(m33), not_nr0_nc3p(m34))
c(not_nr0_nc3p(m40), not_nr0_nc3p(m41), not_nr0_nc3p(m42), not_nr0_nc3p(m43), not_nr0_nc3p(m44))

c(not_nr1p_nc0(m00), not_nr1p_nc0(m01), not_nr1p_nc0(m02), not_nr1p_nc0(m03), not_nr1p_nc0(m04))
c(not_nr1p_nc0(m10), not_nr1p_nc0(m11), not_nr1p_nc0(m12), not_nr1p_nc0(m13), not_nr1p_nc0(m14))
c(not_nr1p_nc0(m20), not_nr1p_nc0(m21), not_nr1p_nc0(m22), not_nr1p_nc0(m23), not_nr1p_nc0(m24))
c(not_nr1p_nc0(m30), not_nr1p_nc0(m31), not_nr1p_nc0(m32), not_nr1p_nc0(m33), not_nr1p_nc0(m34))
c(not_nr1p_nc0(m40), not_nr1p_nc0(m41), not_nr1p_nc0(m42), not_nr1p_nc0(m43), not_nr1p_nc0(m44))

c(not_nr2p_nc0(m00), not_nr2p_nc0(m01), not_nr2p_nc0(m02), not_nr2p_nc0(m03), not_nr2p_nc0(m04))
c(not_nr2p_nc0(m10), not_nr2p_nc0(m11), not_nr2p_nc0(m12), not_nr2p_nc0(m13), not_nr2p_nc0(m14))
c(not_nr2p_nc0(m20), not_nr2p_nc0(m21), not_nr2p_nc0(m22), not_nr2p_nc0(m23), not_nr2p_nc0(m24))
c(not_nr2p_nc0(m30), not_nr2p_nc0(m31), not_nr2p_nc0(m32), not_nr2p_nc0(m33), not_nr2p_nc0(m34))
c(not_nr2p_nc0(m40), not_nr2p_nc0(m41), not_nr2p_nc0(m42), not_nr2p_nc0(m43), not_nr2p_nc0(m44))

c(not_nr3p_nc0(m00), not_nr3p_nc0(m01), not_nr3p_nc0(m02), not_nr3p_nc0(m03), not_nr3p_nc0(m04))
c(not_nr3p_nc0(m10), not_nr3p_nc0(m11), not_nr3p_nc0(m12), not_nr3p_nc0(m13), not_nr3p_nc0(m14))
c(not_nr3p_nc0(m20), not_nr3p_nc0(m21), not_nr3p_nc0(m22), not_nr3p_nc0(m23), not_nr3p_nc0(m24))
c(not_nr3p_nc0(m30), not_nr3p_nc0(m31), not_nr3p_nc0(m32), not_nr3p_nc0(m33), not_nr3p_nc0(m34))
c(not_nr3p_nc0(m40), not_nr3p_nc0(m41), not_nr3p_nc0(m42), not_nr3p_nc0(m43), not_nr3p_nc0(m44))

c(not_nr1p_nc1p(m00), not_nr1p_nc1p(m01), not_nr1p_nc1p(m02), not_nr1p_nc1p(m03), not_nr1p_nc1p(m04))
c(not_nr1p_nc1p(m10), not_nr1p_nc1p(m11), not_nr1p_nc1p(m12), not_nr1p_nc1p(m13), not_nr1p_nc1p(m14))
c(not_nr1p_nc1p(m20), not_nr1p_nc1p(m21), not_nr1p_nc1p(m22), not_nr1p_nc1p(m23), not_nr1p_nc1p(m24))
c(not_nr1p_nc1p(m30), not_nr1p_nc1p(m31), not_nr1p_nc1p(m32), not_nr1p_nc1p(m33), not_nr1p_nc1p(m34))
c(not_nr1p_nc1p(m40), not_nr1p_nc1p(m41), not_nr1p_nc1p(m42), not_nr1p_nc1p(m43), not_nr1p_nc1p(m44))

c(not_nr1p_nc2p(m00), not_nr1p_nc2p(m01), not_nr1p_nc2p(m02), not_nr1p_nc2p(m03), not_nr1p_nc2p(m04))
c(not_nr1p_nc2p(m10), not_nr1p_nc2p(m11), not_nr1p_nc2p(m12), not_nr1p_nc2p(m13), not_nr1p_nc2p(m14))
c(not_nr1p_nc2p(m20), not_nr1p_nc2p(m21), not_nr1p_nc2p(m22), not_nr1p_nc2p(m23), not_nr1p_nc2p(m24))
c(not_nr1p_nc2p(m30), not_nr1p_nc2p(m31), not_nr1p_nc2p(m32), not_nr1p_nc2p(m33), not_nr1p_nc2p(m34))
c(not_nr1p_nc2p(m40), not_nr1p_nc2p(m41), not_nr1p_nc2p(m42), not_nr1p_nc2p(m43), not_nr1p_nc2p(m44))

c(not_nr1p_nc3p(m00), not_nr1p_nc3p(m01), not_nr1p_nc3p(m02), not_nr1p_nc3p(m03), not_nr1p_nc3p(m04))
c(not_nr1p_nc3p(m10), not_nr1p_nc3p(m11), not_nr1p_nc3p(m12), not_nr1p_nc3p(m13), not_nr1p_nc3p(m14))
c(not_nr1p_nc3p(m20), not_nr1p_nc3p(m21), not_nr1p_nc3p(m22), not_nr1p_nc3p(m23), not_nr1p_nc3p(m24))
c(not_nr1p_nc3p(m30), not_nr1p_nc3p(m31), not_nr1p_nc3p(m32), not_nr1p_nc3p(m33), not_nr1p_nc3p(m34))
c(not_nr1p_nc3p(m40), not_nr1p_nc3p(m41), not_nr1p_nc3p(m42), not_nr1p_nc3p(m43), not_nr1p_nc3p(m44))

c(not_nr2p_nc1p(m00), not_nr2p_nc1p(m01), not_nr2p_nc1p(m02), not_nr2p_nc1p(m03), not_nr2p_nc1p(m04))
c(not_nr2p_nc1p(m10), not_nr2p_nc1p(m11), not_nr2p_nc1p(m12), not_nr2p_nc1p(m13), not_nr2p_nc1p(m14))
c(not_nr2p_nc1p(m20), not_nr2p_nc1p(m21), not_nr2p_nc1p(m22), not_nr2p_nc1p(m23), not_nr2p_nc1p(m24))
c(not_nr2p_nc1p(m30), not_nr2p_nc1p(m31), not_nr2p_nc1p(m32), not_nr2p_nc1p(m33), not_nr2p_nc1p(m34))
c(not_nr2p_nc1p(m40), not_nr2p_nc1p(m41), not_nr2p_nc1p(m42), not_nr2p_nc1p(m43), not_nr2p_nc1p(m44))

c(not_nr2p_nc2p(m00), not_nr2p_nc2p(m01), not_nr2p_nc2p(m02), not_nr2p_nc2p(m03), not_nr2p_nc2p(m04))
c(not_nr2p_nc2p(m10), not_nr2p_nc2p(m11), not_nr2p_nc2p(m12), not_nr2p_nc2p(m13), not_nr2p_nc2p(m14))
c(not_nr2p_nc2p(m20), not_nr2p_nc2p(m21), not_nr2p_nc2p(m22), not_nr2p_nc2p(m23), not_nr2p_nc2p(m24))
c(not_nr2p_nc2p(m30), not_nr2p_nc2p(m31), not_nr2p_nc2p(m32), not_nr2p_nc2p(m33), not_nr2p_nc2p(m34))
c(not_nr2p_nc2p(m40), not_nr2p_nc2p(m41), not_nr2p_nc2p(m42), not_nr2p_nc2p(m43), not_nr2p_nc2p(m44))

c(not_nr2p_nc3p(m00), not_nr2p_nc3p(m01), not_nr2p_nc3p(m02), not_nr2p_nc3p(m03), not_nr2p_nc3p(m04))
c(not_nr2p_nc3p(m10), not_nr2p_nc3p(m11), not_nr2p_nc3p(m12), not_nr2p_nc3p(m13), not_nr2p_nc3p(m14))
c(not_nr2p_nc3p(m20), not_nr2p_nc3p(m21), not_nr2p_nc3p(m22), not_nr2p_nc3p(m23), not_nr2p_nc3p(m24))
c(not_nr2p_nc3p(m30), not_nr2p_nc3p(m31), not_nr2p_nc3p(m32), not_nr2p_nc3p(m33), not_nr2p_nc3p(m34))
c(not_nr2p_nc3p(m40), not_nr2p_nc3p(m41), not_nr2p_nc3p(m42), not_nr2p_nc3p(m43), not_nr2p_nc3p(m44))

c(not_nr3p_nc1p(m00), not_nr3p_nc1p(m01), not_nr3p_nc1p(m02), not_nr3p_nc1p(m03), not_nr3p_nc1p(m04))
c(not_nr3p_nc1p(m10), not_nr3p_nc1p(m11), not_nr3p_nc1p(m12), not_nr3p_nc1p(m13), not_nr3p_nc1p(m14))
c(not_nr3p_nc1p(m20), not_nr3p_nc1p(m21), not_nr3p_nc1p(m22), not_nr3p_nc1p(m23), not_nr3p_nc1p(m24))
c(not_nr3p_nc1p(m30), not_nr3p_nc1p(m31), not_nr3p_nc1p(m32), not_nr3p_nc1p(m33), not_nr3p_nc1p(m34))
c(not_nr3p_nc1p(m40), not_nr3p_nc1p(m41), not_nr3p_nc1p(m42), not_nr3p_nc1p(m43), not_nr3p_nc1p(m44))

c(not_nr3p_nc2p(m00), not_nr3p_nc2p(m01), not_nr3p_nc2p(m02), not_nr3p_nc2p(m03), not_nr3p_nc2p(m04))
c(not_nr3p_nc2p(m10), not_nr3p_nc2p(m11), not_nr3p_nc2p(m12), not_nr3p_nc2p(m13), not_nr3p_nc2p(m14))
c(not_nr3p_nc2p(m20), not_nr3p_nc2p(m21), not_nr3p_nc2p(m22), not_nr3p_nc2p(m23), not_nr3p_nc2p(m24))
c(not_nr3p_nc2p(m30), not_nr3p_nc2p(m31), not_nr3p_nc2p(m32), not_nr3p_nc2p(m33), not_nr3p_nc2p(m34))
c(not_nr3p_nc2p(m40), not_nr3p_nc2p(m41), not_nr3p_nc2p(m42), not_nr3p_nc2p(m43), not_nr3p_nc2p(m44))

c(not_nr3p_nc3p(m00), not_nr3p_nc3p(m01), not_nr3p_nc3p(m02), not_nr3p_nc3p(m03), not_nr3p_nc3p(m04))
c(not_nr3p_nc3p(m10), not_nr3p_nc3p(m11), not_nr3p_nc3p(m12), not_nr3p_nc3p(m13), not_nr3p_nc3p(m14))
c(not_nr3p_nc3p(m20), not_nr3p_nc3p(m21), not_nr3p_nc3p(m22), not_nr3p_nc3p(m23), not_nr3p_nc3p(m24))
c(not_nr3p_nc3p(m30), not_nr3p_nc3p(m31), not_nr3p_nc3p(m32), not_nr3p_nc3p(m33), not_nr3p_nc3p(m34))
c(not_nr3p_nc3p(m40), not_nr3p_nc3p(m41), not_nr3p_nc3p(m42), not_nr3p_nc3p(m43), not_nr3p_nc3p(m44))

##
## DEFINE ARRAY VARIABLE SET
##

a <- function(...) {array(1, dim = unlist(list(...), use.names = F))}

a0 <- NULL
a1 <- a(1)
a11 <- a(1, 1)
a111 <- a(1, 1, 1)
a1111 <- a(1, 1, 1, 1)

##
## DEMO [ndim], [ndimX], [ndimXp], [not_ndimX], AND [not_ndimXp] FUNCTIONS
##

c(ndim(a0), ndim(a1), ndim(a11), ndim(a111), ndim(a1111))

c(ndim0(a0), ndim0(a1), ndim0(a11), ndim0(a111), ndim0(a1111))
c(ndim1(a0), ndim1(a1), ndim1(a11), ndim1(a111), ndim1(a1111))
c(ndim2(a0), ndim2(a1), ndim2(a11), ndim2(a111), ndim2(a1111))
c(ndim3(a0), ndim3(a1), ndim3(a11), ndim3(a111), ndim3(a1111))

c(ndim1p(a0), ndim1p(a1), ndim1p(a11), ndim1p(a111), ndim1p(a1111))
c(ndim2p(a0), ndim2p(a1), ndim2p(a11), ndim2p(a111), ndim2p(a1111))
c(ndim3p(a0), ndim3p(a1), ndim3p(a11), ndim3p(a111), ndim3p(a1111))

c(not_ndim0(a0), not_ndim0(a1), not_ndim0(a11), not_ndim0(a111), not_ndim0(a1111))
c(not_ndim1(a0), not_ndim1(a1), not_ndim1(a11), not_ndim1(a111), not_ndim1(a1111))
c(not_ndim2(a0), not_ndim2(a1), not_ndim2(a11), not_ndim2(a111), not_ndim2(a1111))
c(not_ndim3(a0), not_ndim3(a1), not_ndim3(a11), not_ndim3(a111), not_ndim3(a1111))

c(not_ndim1p(a0), not_ndim1p(a1), not_ndim1p(a11), not_ndim1p(a111), not_ndim1p(a1111))
c(not_ndim2p(a0), not_ndim2p(a1), not_ndim2p(a11), not_ndim2p(a111), not_ndim2p(a1111))
c(not_ndim3p(a0), not_ndim3p(a1), not_ndim3p(a11), not_ndim3p(a111), not_ndim3p(a1111))

##
## DEFINE [NA] VARIABLE SET
##

na0 <- na1 <- na2 <- na3 <- na4 <- letters
na1[5] <- NA
na2[c(5, 10)] <- NA
na3[c(5, 10, 15)] <- NA
na4[c(5, 10, 15, 25)] <- NA

##
## DEMO [nnav], [nnavX], [nnavXp], [not_nnavX], AND [not_nnavXp] FUNCTIONS
##

c(nnav(na0), nnav(na1), nnav(na2), nnav(na3), nnav(na4))

c(nnav0(na0), nnav0(na1), nnav0(na2), nnav0(na3), nnav0(na4))
c(nnav1(na0), nnav1(na1), nnav1(na2), nnav1(na3), nnav1(na4))
c(nnav2(na0), nnav2(na1), nnav2(na2), nnav2(na3), nnav2(na4))
c(nnav3(na0), nnav3(na1), nnav3(na2), nnav3(na3), nnav3(na4))

c(nnav1p(na0), nnav1p(na1), nnav1p(na2), nnav1p(na3), nnav1p(na4))
c(nnav2p(na0), nnav2p(na1), nnav2p(na2), nnav2p(na3), nnav2p(na4))
c(nnav3p(na0), nnav3p(na1), nnav3p(na2), nnav3p(na3), nnav3p(na4))

c(not_nnav0(na0), not_nnav0(na1), not_nnav0(na2), not_nnav0(na3), not_nnav0(na4))
c(not_nnav1(na0), not_nnav1(na1), not_nnav1(na2), not_nnav1(na3), not_nnav1(na4))
c(not_nnav2(na0), not_nnav2(na1), not_nnav2(na2), not_nnav2(na3), not_nnav2(na4))
c(not_nnav3(na0), not_nnav3(na1), not_nnav3(na2), not_nnav3(na3), not_nnav3(na4))

c(not_nnav1p(na0), not_nnav1p(na1), not_nnav1p(na2), not_nnav1p(na3), not_nnav1p(na4))
c(not_nnav2p(na0), not_nnav2p(na1), not_nnav2p(na2), not_nnav2p(na3), not_nnav2p(na4))
c(not_nnav3p(na0), not_nnav3p(na1), not_nnav3p(na2), not_nnav3p(na3), not_nnav3p(na4))

##
## DEFINE [OK] VARIABLE SET
##

ok0 <- ok1 <- ok2 <- ok3 <- ok4 <- 0:9
ok0[1:10] <- NA
ok1[1:9] <- NA
ok2[1:8] <- NA
ok3[1:7] <- NA
ok4[1:6] <- NA

##
## DEMO [nokv], [nokvX], [nokvXp], [not_nokvX], AND [not_nokvXp] FUNCTIONS
##

c(nokv(ok0), nokv(ok1), nokv(ok2), nokv(ok3), nokv(ok4))

c(nokv0(ok0), nokv0(ok1), nokv0(ok2), nokv0(ok3), nokv0(ok4))
c(nokv1(ok0), nokv1(ok1), nokv1(ok2), nokv1(ok3), nokv1(ok4))
c(nokv2(ok0), nokv2(ok1), nokv2(ok2), nokv2(ok3), nokv2(ok4))
c(nokv3(ok0), nokv3(ok1), nokv3(ok2), nokv3(ok3), nokv3(ok4))

c(nokv1p(ok0), nokv1p(ok1), nokv1p(ok2), nokv1p(ok3), nokv1p(ok4))
c(nokv2p(ok0), nokv2p(ok1), nokv2p(ok2), nokv2p(ok3), nokv2p(ok4))
c(nokv3p(ok0), nokv3p(ok1), nokv3p(ok2), nokv3p(ok3), nokv3p(ok4))

c(not_nokv0(ok0), not_nokv0(ok1), not_nokv0(ok2), not_nokv0(ok3), not_nokv0(ok4))
c(not_nokv1(ok0), not_nokv1(ok1), not_nokv1(ok2), not_nokv1(ok3), not_nokv1(ok4))
c(not_nokv2(ok0), not_nokv2(ok1), not_nokv2(ok2), not_nokv2(ok3), not_nokv2(ok4))
c(not_nokv3(ok0), not_nokv3(ok1), not_nokv3(ok2), not_nokv3(ok3), not_nokv3(ok4))

c(not_nokv1p(ok0), not_nokv1p(ok1), not_nokv1p(ok2), not_nokv1p(ok3), not_nokv1p(ok4))
c(not_nokv2p(ok0), not_nokv2p(ok1), not_nokv2p(ok2), not_nokv2p(ok3), not_nokv2p(ok4))
c(not_nokv3p(ok0), not_nokv3p(ok1), not_nokv3p(ok2), not_nokv3p(ok3), not_nokv3p(ok4))

##
## DEFINE LIST VARIABLE SET
##

NS0 <- list(a = NULL, b = NULL)
NS1 <- list(a = 1, b = 2)
NS2 <- list(a = 1:2, b = 3:4)
NS3 <- list(a = 1:3, b = 4:6)
NS4 <- list(a = 1:4, b = 5:8)
NSx <- list(a = 1, b = 2:3)

##
## DEMO [ns], [nsX], [nxXp], [not_nsX], AND [not_nsXp] FUNCTIONS
##

list(NS0 = ns(NS0), NS1 = ns(NS1), NS2 = ns(NS2), NS3 = ns(NS3), NS4 = ns(NS4), NSx = ns(NSx))

c(ns0(NS0), ns0(NS1), ns0(NS2), ns0(NS3), ns0(NS4), ns0(NSx))
c(ns1(NS0), ns1(NS1), ns1(NS2), ns1(NS3), ns1(NS4), ns1(NSx))
c(ns2(NS0), ns2(NS1), ns2(NS2), ns2(NS3), ns2(NS4), ns2(NSx))
c(ns3(NS0), ns3(NS1), ns3(NS2), ns3(NS3), ns3(NS4), ns3(NSx))

c(ns1p(NS0), ns1p(NS1), ns1p(NS2), ns1p(NS3), ns1p(NS4), ns1p(NSx))
c(ns2p(NS0), ns2p(NS1), ns2p(NS2), ns2p(NS3), ns2p(NS4), ns2p(NSx))
c(ns3p(NS0), ns3p(NS1), ns3p(NS2), ns3p(NS3), ns3p(NS4), ns3p(NSx))

c(not_ns0(NS0), not_ns0(NS1), not_ns0(NS2), not_ns0(NS3), not_ns0(NS4), not_ns0(NSx))
c(not_ns1(NS0), not_ns1(NS1), not_ns1(NS2), not_ns1(NS3), not_ns1(NS4), not_ns1(NSx))
c(not_ns2(NS0), not_ns2(NS1), not_ns2(NS2), not_ns2(NS3), not_ns2(NS4), not_ns2(NSx))
c(not_ns3(NS0), not_ns3(NS1), not_ns3(NS2), not_ns3(NS3), not_ns3(NS4), not_ns3(NSx))

c(not_ns1p(NS0), not_ns1p(NS1), not_ns1p(NS2), not_ns1p(NS3), not_ns1p(NS4), not_ns1p(NSx))
c(not_ns2p(NS0), not_ns2p(NS1), not_ns2p(NS2), not_ns2p(NS3), not_ns2p(NS4), not_ns2p(NSx))
c(not_ns3p(NS0), not_ns3p(NS1), not_ns3p(NS2), not_ns3p(NS3), not_ns3p(NS4), not_ns3p(NSx))


j-martineau/uj documentation built on Sept. 14, 2024, 4:40 a.m.