What is the HDIM Algorithms package anyway?

Here are some examples to get you started.

          #include < eigen3/Eigen/Dense >
          #include "x_fos.hpp"

          int main(int argc, char *argv[]) {

              (void)argc;
              (void)argv;

              unsigned int N = 200; // Number of observations
              unsigned int P = 500; // Number of variables

              // Generate a random 'data' matrix
              Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > X =
              Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >::Random( N , P );

              // Generate a random 'predictors' vector
              Eigen::Matrix< double, Eigen::Dynamic, 1 > Y =
              Eigen::Matrix< double, Eigen::Dynamic, 1 >::Random( N, 1 );

              // Initialize the FOS functor
              hdim::X_FOS fos;

              // Run the FOS algorithm using the data matrix and vector of predictors.
              // The third arguement is the type of iterative solver that we want to
              // use, in this cas Coordinate Descent ( CD )
              fos( X, Y, hdim::SolverType::cd );

              // Return the computed regression coefficients
              Eigen::Matrix< T, Eigen::Dynamic, 1 > fos_fit = fos.ReturnCoefficients();

              // Return the intercept term
              double intercept = fos.ReturnIntercept();

              std::cout << "Intercept: " << intercept << "\n Coefficients: " << fos_fit << std::endl;

          }
        

          library(HDIM)

          dataset <- matrix(rexp(200, rate=.1), ncol=20)

          yinput <- dataset[, 1, drop = FALSE]
          xinput <- dataset[, names(dataset) != names(yinput)]

          fos_fit <- HDIM::FOS( as.matrix(xinput), as.matrix(yinput), "cd" )

        

          import hdim
          import numpy as np

          def main():
          	N = 200 # Number of observations
          	P = 500 # Number of variables

            # Generate synthetic data matrix
            X = np.random.rand( 200, 500 )
            # Use first column of data matrix as vector of predictors
            Y = X[:,0]

            # Initialize FOS functor
            fos_test = hdim.X_FOS_d()

            # Run the FOS Algorithm using the data matrix and vector of predictors
            # The third function argument is the type of th iterative solver used
            # in this case Coordinate Descent ( CD )
            fos_test( X, Y, hdim.SolverType_cd )

            fos_fit = fos_test.ReturnCoefficients() # Get the computed coefficients
            intercept = fos_test.ReturnIntercept() # And the intercept

          if __name__ == "__main__":
              main()
        

          var tools = require( "./fos.js" )

          var fos = new tools.FOS();

          var vectorized_X = new tools.VectorDouble();

          var n = 20;
          var p = 50;

          for ( i = 0; i < n * p ; i++ ) {
              vectorized_X.push_back( Math.random() );
          }

          var Y = new tools.VectorDouble();

          for ( i = 0; i < n * 1 ; i++ ) {
              Y.push_back( Math.random() );
          }

          fos.Run( vectorized_X, Y, "cd" )

          var coefs = fos.ReturnCoefficients();
          var intercept = fos.ReturnIntercept();

          console.log( "Intercept: ", intercept );
          console.log( "Beta Vector:" );

          for ( i = 0; i < coefs.size() ; i++ ) {
              console.log( coefs.get(i) );
          }