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.823 -0.134 -0.812  2.30 
#> 2  0.998  0.499  1.04   2.28 
#> 3 -1.56  -2.88   2.95   0.818
#> 4  1.86  -1.69   0.492 -0.360
#> 5 -2.20   0.685  3.87  -3.07 
#> 6  0.764  2.26   0.322 -2.71

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.747 -0.213  2.30  -1.49  
#> 2 -4.41  -1.79   1.87  -0.837 
#> 3 -2.55   0.662 -2.83   4.41  
#> 4  1.78  -3.74  -0.470 -3.62  
#> 5 -1.80  -0.349  2.83  -0.0742
#> 6 -0.468  0.118  0.635  1.71

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  6.58   1.10   0.478  0.199        1
#> 2  4.64  -0.754  0.659 -0.717        1
#> 3  0.619  0.197  4.56   0.0641       3
#> 4  4.85   0.105 -1.09   0.372        1
#> 5 -1.09   5.76  -1.34   0.579        2
#> 6 -1.78  -1.21   3.96   0.437        3

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.1230575 -0.02009165 -0.12143957  0.34414502
#> 2  0.1492143  0.07466953  0.15500270  0.34140807
#> 3 -0.2340221 -0.43096428  0.44060943  0.12234143
#> 4  0.2788405 -0.25340294  0.07362468 -0.05380976
#> 5 -0.3294756  0.10242787  0.57862629 -0.45903543
#> 6  0.1142282  0.33767189  0.04810503 -0.40555615

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.1885900 -0.5344571 -1.2917355  0.75624261  0.8813600
#> [2,] -0.1301800  0.6187381 -0.1351836  0.05984047 -0.4132150
#> [3,] -0.9353013 -0.5672970  0.7918940  0.19115273  0.5195516
#> [4,]  0.6219929  0.1489680  0.4604754 -0.36807512 -0.8633612

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 33 34

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