Additional functions

library(cardinalR)

These are helper functions included in the package.

Generating background noise

The gen_bkgnoise() function allows users to generate multivariate Gaussian noise to serve as background data in high-dimensional spaces.

# Example: Generate 4D background noise
bkg_data <- gen_bkgnoise(n = 500, p = 4, 
                         m = c(0, 0, 0, 0), s = c(2, 2, 2, 2))
head(bkg_data)
#> # A tibble: 6 × 4
#>       x1     x2     x3     x4
#>    <dbl>  <dbl>  <dbl>  <dbl>
#> 1  0.441 -0.988  2.29  -0.272
#> 2 -2.26   3.47  -0.393  1.36 
#> 3 -3.33   4.23  -1.53  -3.25 
#> 4 -0.825 -0.175  4.42   1.32 
#> 5 -0.312  0.298 -0.631 -1.10 
#> 6  1.08   1.28   3.93  -2.99

The generated data has independent dimensions with specified means (m) and standard deviations (s).

Randomizing rows

randomize_rows() ensures the rows of the input data is randomized.

randomized_data <- randomize_rows(bkg_data)
head(randomized_data)
#> # A tibble: 6 × 4
#>       x1      x2     x3     x4
#>    <dbl>   <dbl>  <dbl>  <dbl>
#> 1 -0.811  2.76    2.09  -3.66 
#> 2 -0.927 -2.18   -0.613 -0.191
#> 3 -1.57   0.521   3.51  -0.572
#> 4  4.02  -0.401   1.32   0.356
#> 5 -0.322  1.81   -2.80   0.434
#> 6  3.94  -0.0327  1.13  -1.84

Relocating clusters

relocate_clusters() allows users to translate clusters in any dimension(s). This is achieved by centering each cluster (subtracting its mean) and then adding a translation vector from a provided matrix (vert_mat).

df <- tibble::tibble(
  x1 = rnorm(12),
  x2 = rnorm(12),
  x3 = rnorm(12),
  x4 = rnorm(12),
  cluster = rep(1:3, each = 4)
)

vert_mat <- matrix(c(
  5, 0, 0, 0,
  0, 5, 0, 0,
  0, 0, 5, 0
), nrow = 3, byrow = TRUE)

relocated_df <- relocate_clusters(df, vert_mat)
head(relocated_df)
#> # A tibble: 6 × 5
#>       x1     x2     x3      x4 cluster
#>    <dbl>  <dbl>  <dbl>   <dbl>   <int>
#> 1  0.713  1.46   5.07   0.579        3
#> 2  5.10  -1.04   0.691  0.0187       1
#> 3 -0.864  5.13   0.660  1.53         2
#> 4  0.590  6.42  -1.27   0.586        2
#> 5  3.63  -0.789 -1.40  -0.0663       1
#> 6  5.36   1.06   1.34  -1.01         1

Generating Rotation Matrices

The gen_rotation() function creates a rotation matrix in high-dimensional space for given planes and angles.


rotations_4d <- list(
  list(plane = c(1, 2), angle = 60),
  list(plane = c(3, 4), angle = 90)
)

rot_mat <- gen_rotation(p = 4, planes_angles = rotations_4d)
rot_mat
#>           [,1]       [,2]         [,3]          [,4]
#> [1,] 0.5000000 -0.8660254 0.000000e+00  0.000000e+00
#> [2,] 0.8660254  0.5000000 0.000000e+00  0.000000e+00
#> [3,] 0.0000000  0.0000000 6.123234e-17 -1.000000e+00
#> [4,] 0.0000000  0.0000000 1.000000e+00  6.123234e-17

Normalize data

When combining clusters or transforming data geometrically, magnitudes can differ drastically. The normalize_data() function rescales the entire dataset to fit within ([-1, 1]) based on its maximum absolute value.

norm_data <- normalize_data(bkg_data)
head(norm_data)
#>            x1          x2          x3         x4
#> 1  0.06342707 -0.14203337  0.32864032 -0.0390901
#> 2 -0.32454564  0.49938104 -0.05650814  0.1948634
#> 3 -0.47820086  0.60855657 -0.21973945 -0.4671170
#> 4 -0.11853771 -0.02514577  0.63473886  0.1893692
#> 5 -0.04479845  0.04276241 -0.09068026 -0.1584683
#> 6  0.15575811  0.18334265  0.56447252 -0.4302864

Generating cluster locations

To place clusters in different positions, gen_clustloc() generates points forming a simplex-like arrangement ensuring each cluster center is equidistant from others as much as possible.


centers <- gen_clustloc(p = 4, k = 5)
head(centers)
#>            [,1]       [,2]       [,3]       [,4]       [,5]
#> [1,] -0.2924342  0.0276422  0.3325126 -0.8228585  0.7551379
#> [2,] -0.8963955 -0.4852194 -0.2814276  1.8067166 -0.1436741
#> [3,] -0.1288672  0.0269079 -0.6890171  1.0888255 -0.2978491
#> [4,]  1.1694518 -0.1954048 -0.1803966 -0.0650291 -0.7286213

Numeric generators

Two helper functions, gen_nproduct() and gen_nsum(), generate numeric vectors of positive integers that approximately satisfy a user-specified target product or sum, respectively.

The function gen_nsum(n, k) divides a total sum n into k positive integers. It first assigns an equal base value to each element and then randomly distributes any remainder, ensuring the elements sum exactly to n.

gen_nsum(n = 100, k = 3)
#> [1] 33 34 33

The function gen_nproduct(n, p) aims to produce p positive integers whose product is approximately n. It starts with all elements equal to the rounded \(p^{th}\) root of n and iteratively adjusts elements up or down in a randomized manner until the product is within a small tolerance of n. This accommodates the fact that exact integer solutions for a given product are often impossible.

gen_nproduct(n = 500, p = 4)
#> [1] 4 5 5 5