[Rcpp-commits] r4275 - in pkg/RcppArmadillo: . inst inst/doc inst/include inst/include/armadillo_bits
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Fri Mar 1 15:22:45 CET 2013
Author: edd
Date: 2013-03-01 15:22:44 +0100 (Fri, 01 Mar 2013)
New Revision: 4275
Added:
pkg/RcppArmadillo/inst/CITATION
pkg/RcppArmadillo/inst/doc/elsarticle-harv.bst
pkg/RcppArmadillo/inst/doc/elsarticle.cls
pkg/RcppArmadillo/inst/include/armadillo_bits/op_toeplitz_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_toeplitz_meat.hpp
Modified:
pkg/RcppArmadillo/.Rinstignore
pkg/RcppArmadillo/ChangeLog
pkg/RcppArmadillo/DESCRIPTION
pkg/RcppArmadillo/inst/NEWS.Rd
pkg/RcppArmadillo/inst/doc/Makefile
pkg/RcppArmadillo/inst/doc/RcppArmadillo-intro.Rnw
pkg/RcppArmadillo/inst/doc/RcppArmadillo.bib
pkg/RcppArmadillo/inst/include/armadillo
pkg/RcppArmadillo/inst/include/armadillo_bits/BaseCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/BaseCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Base_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Base_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Col_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Col_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Cube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Cube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/GenCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/GenCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Gen_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Gen_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/GlueCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/GlueCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Glue_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Glue_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Mat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Mat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/OpCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/OpCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Op_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Op_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Proxy.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/ProxyCube.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Row_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/Row_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpBase_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpBase_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpCol_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpCol_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpGlue_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpGlue_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpMat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpMat_iterators_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpMat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpOp_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpOp_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpProxy.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpRow_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpRow_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpSubview_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpSubview_iterators_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpSubview_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpValProxy_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/SpValProxy_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/access.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arma_config.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arma_ostream_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arma_ostream_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arma_static_check.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arma_version.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arrayops_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/arrayops_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/atlas_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/atlas_wrapper.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/auxlib_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/auxlib_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/blas_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/blas_wrapper.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/cmath_wrap.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/compiler_setup.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/cond_rel_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/cond_rel_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/config.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/constants.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/constants_compat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/debug.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/diagmat_proxy.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/diagview_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/diagview_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/diskio_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/diskio_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eGlueCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eGlueCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eGlue_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eGlue_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eOpCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eOpCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eOp_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eOp_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eglue_core_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eglue_core_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eop_aux.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eop_core_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/eop_core_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/field_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/field_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_accu.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_as_scalar.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_chol.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_conv.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_conv_to.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_cor.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_cov.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_cross.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_cumsum.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_det.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_diagmat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_diagvec.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_dot.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_eig.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_elem.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_eps.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_eye.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_flip.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_hist.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_histc.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_inv.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_join.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_kron.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_log_det.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_lu.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_max.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_mean.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_median.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_min.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_misc.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_n_unique.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_norm.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_ones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_pinv.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_princomp.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_prod.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_qr.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_randn.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_randu.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_rank.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_repmat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_reshape.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_resize.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_shuffle.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_solve.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_sort.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_sort_index.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_speye.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_spones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_sprandn.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_sprandu.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_stddev.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_strans.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_sum.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_svd.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_syl_lyap.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_symmat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_toeplitz.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trace.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trans.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trig.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trimat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trunc_exp.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_trunc_log.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_unique.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_var.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/fn_zeros.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/format_wrap.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/forward_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/gemm.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/gemm_mixed.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/gemv.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_conv_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_conv_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cor_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cor_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cov_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cov_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cross_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_cross_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_hist_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_hist_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_histc_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_histc_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_join_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_join_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_kron_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_kron_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_mixed_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_mixed_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_relational_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_relational_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_solve_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_solve_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_times_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_times_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_toeplitz_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/glue_toeplitz_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/hdf5_misc.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/include_atlas.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/injector_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/injector_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/lapack_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/lapack_wrapper.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/memory.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtGlueCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtGlueCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtGlue_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtGlue_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtOpCube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtOpCube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtOp_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtOp_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtSpOp_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/mtSpOp_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_chol_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_chol_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cor_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cor_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cov_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cov_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cumsum_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cumsum_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cx_scalar_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_cx_scalar_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_diagmat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_diagmat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_diagvec_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_diagvec_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_dot_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_dot_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_dotext_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_dotext_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_find_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_find_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_flip_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_flip_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_hist_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_hist_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_htrans_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_htrans_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_inv_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_inv_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_max_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_max_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_mean_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_mean_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_median_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_median_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_min_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_min_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_misc_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_misc_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_pinv_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_pinv_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_princomp_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_princomp_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_prod_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_prod_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_relational_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_relational_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_repmat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_repmat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_reshape_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_reshape_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_resize_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_resize_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_shuffle_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_shuffle_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_sort_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_sort_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_stddev_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_stddev_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_strans_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_strans_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_sum_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_sum_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_symmat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_symmat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_trimat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_trimat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_unique_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_unique_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_var_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/op_var_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_div.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_minus.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_plus.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_relational.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_schur.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_cube_times.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_div.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_minus.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_ostream.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_plus.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_relational.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_schur.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/operator_times.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/podarray_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/podarray_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/promote_type.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/restrictors.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/running_stat_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/running_stat_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/running_stat_vec_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/running_stat_vec_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/span.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_minus_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_minus_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_plus_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_plus_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_times_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spglue_times_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_htrans_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_htrans_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_max_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_max_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_mean_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_mean_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_min_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_min_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_misc_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_misc_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_strans_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_strans_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_sum_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_sum_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_var_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/spop_var_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/strip.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_cube_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_cube_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_each_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_each_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_elem1_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_elem1_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_elem2_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_elem2_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_field_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_field_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/subview_meat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/traits.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/typedef.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/typedef_blas_int.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/typedef_fixed.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/undefine_conflicts.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/unwrap.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/unwrap_cube.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/unwrap_spmat.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/upgrade_val.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/wall_clock_bones.hpp
pkg/RcppArmadillo/inst/include/armadillo_bits/wall_clock_meat.hpp
Log:
RcppArmadillo 0.3.800.0 with Armadillo 3.800.0
Updated vignette to CSDA paper
Added CITATION
Modified: pkg/RcppArmadillo/.Rinstignore
===================================================================
--- pkg/RcppArmadillo/.Rinstignore 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/.Rinstignore 2013-03-01 14:22:44 UTC (rev 4275)
@@ -1 +1,3 @@
inst/doc/Makefile
+inst/doc/elsarticle-harv.bst
+inst/doc/elsarticle.cls
Modified: pkg/RcppArmadillo/ChangeLog
===================================================================
--- pkg/RcppArmadillo/ChangeLog 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/ChangeLog 2013-03-01 14:22:44 UTC (rev 4275)
@@ -1,3 +1,18 @@
+2013-03-01 Dirk Eddelbuettel <edd at debian.org>
+
+ * DESCRIPTION: Release 0.3.800.0
+ * DESCRIPTION: Updated Description to reflect change of Armadillo
+ license to MPL 2.0 (which is fully compatible with GPL so no change
+ or net effect to RcppArmadillo)
+
+ * inst/include/*: Upgraded to new release 3.800.0 of Armadillo
+
+ * inst/doc/RcppArmadillo-intro.Rnw: Updated vignette to preprint of
+ the Computational Statistics & Data Analysis paper in press
+ * inst/doc/*: Added or updated relevant support files
+
+ * inst/CITATION: Added with reference to CSDA paper
+
2013-02-20 Dirk Eddelbuettel <edd at debian.org>
* DESCRIPTION: Release 0.3.6.3
Modified: pkg/RcppArmadillo/DESCRIPTION
===================================================================
--- pkg/RcppArmadillo/DESCRIPTION 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/DESCRIPTION 2013-03-01 14:22:44 UTC (rev 4275)
@@ -1,7 +1,7 @@
Package: RcppArmadillo
Type: Package
Title: Rcpp integration for Armadillo templated linear algebra library
-Version: 0.3.6.3
+Version: 0.3.800.0
Date: $Date$
Author: Romain Francois, Dirk Eddelbuettel and Doug Bates
Maintainer: Dirk Eddelbuettel <edd at debian.org>
@@ -21,15 +21,15 @@
(due to speed and/or integration capabilities), rather than another language.
.
The RcppArmadillo package includes the header files from the templated
- Armadillo library (currently version 3.6.3). Thus users do not need to
+ Armadillo library (currently version 3.800.0). Thus users do not need to
install Armadillo itself in order to use RcppArmadillo.
.
This Armadillo integration provides a nice illustration of the
capabilities of the Rcpp package for seamless R and C++ integration.
.
- Armadillo is licensed under the GNU LGPL version 3 or later, while
- RcppArmadillo (the Rcpp bindings/bridge to Armadillo) is licensed under
- the GNU GPL version 2 or later, as is the rest of Rcpp.
+ Armadillo is licensed under the MPL 2.0, while RcppArmadillo (the Rcpp
+ bindings/bridge to Armadillo) is licensed under the GNU GPL version 2
+ or later, as is the rest of Rcpp.
License: GPL (>= 2)
LazyLoad: yes
Depends: R (>= 2.14.0), Rcpp (>= 0.9.10)
Added: pkg/RcppArmadillo/inst/CITATION
===================================================================
--- pkg/RcppArmadillo/inst/CITATION (rev 0)
+++ pkg/RcppArmadillo/inst/CITATION 2013-03-01 14:22:44 UTC (rev 4275)
@@ -0,0 +1,19 @@
+citHeader("To cite RcppArmadillo in publications use:")
+
+citEntry(entry = "Article",
+ title = "RcppArmadillo: Accelerating R with high-performance C++ linear algebra",
+ author = personList(as.person("Dirk Eddelbuettel"),
+ as.person("Conrad Sanderson")),
+ journal = "Computational Statistics and Data Analysis",
+ year = "2013",
+ volume = "in press",
+ number = "",
+ pages = "",
+ url = "http://dx.doi.org/10.1016/j.csda.2013.02.005",
+
+ textVersion =
+ paste("Dirk Eddelbuettel, Conrad Sanderson (2013).",
+ "RcppArmadillo: Accelerating R with high-performance C++ linear algebra.",
+ "Computational Statistics and Data Analysis, in press.",
+ "URL http://dx.doi.org/10.1016/j.csda.2013.02.005")
+)
Modified: pkg/RcppArmadillo/inst/NEWS.Rd
===================================================================
--- pkg/RcppArmadillo/inst/NEWS.Rd 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/inst/NEWS.Rd 2013-03-01 14:22:44 UTC (rev 4275)
@@ -2,6 +2,25 @@
\title{News for Package 'RcppArmadillo'}
\newcommand{\cpkg}{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}}
+\section{Changes in RcppArmadillo version 0.3.800.0 (2013-03-01)}{
+ \itemize{
+ \item Upgraded to Armadillo release Version 3.800.0 (Miami Beach)
+ \itemize{
+ \item Armadillo is now licensed using the Mozilla Public License 2.0
+ \item added \code{.imbue()} for filling a matrix/cube with values provided by a functor or lambda expression
+ \item added \code{.swap()} for swapping contents with another matrix
+ \item added \code{.transform()} for transforming a matrix/cube using a functor or lambda expression
+ \item added \code{round()} for rounding matrix elements towards nearest integer
+ \item faster \code{find()}
+ \item fixes for handling non-square matrices by \code{qr()} and \code{qr_econ()}
+ \item minor fixes for handling empty matrices
+ \item reduction of pedantic compiler warnings
+ }
+ \item Updated vignette to paper now in press at CSDA
+ \item Added CITATION file with reference to CSDA paper
+ }
+}
+
\section{Changes in RcppArmadillo version 0.3.6.3 (2013-02-20)}{
\itemize{
\item Upgraded to Armadillo release Version 3.6.3
@@ -27,7 +46,7 @@
\section{Changes in RcppArmadillo version 0.3.6.1 (2012-12-17)}{
\itemize{
- \item Upgraded to Armadillo release Version 3.6.1
+ \item Upgraded to Armadillo release Version 3.6.1 (Piazza del Duomo)
\itemize{
\item faster \code{trace()}
\item fix for handling sparse matrices by \code{dot()}
Modified: pkg/RcppArmadillo/inst/doc/Makefile
===================================================================
--- pkg/RcppArmadillo/inst/doc/Makefile 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/inst/doc/Makefile 2013-03-01 14:22:44 UTC (rev 4275)
@@ -24,8 +24,8 @@
RcppArmadillo-intro.pdf:
${RPROG} CMD Sweave RcppArmadillo-intro.Rnw
- pdflatex RcppArmadillo-intro
+ pdflatex -shell-escape RcppArmadillo-intro
bibtex RcppArmadillo-intro
- pdflatex RcppArmadillo-intro
- pdflatex RcppArmadillo-intro
- rm RcppArmadillo-intro.aux RcppArmadillo-intro.log RcppArmadillo-intro.bbl RcppArmadillo-intro.blg RcppArmadillo-intro.tex
\ No newline at end of file
+ pdflatex -shell-escape RcppArmadillo-intro
+ pdflatex -shell-escape RcppArmadillo-intro
+ rm RcppArmadillo-intro.aux RcppArmadillo-intro.log RcppArmadillo-intro.bbl RcppArmadillo-intro.blg RcppArmadillo-intro.tex RcppArmadillo-intro.spl
Modified: pkg/RcppArmadillo/inst/doc/RcppArmadillo-intro.Rnw
===================================================================
--- pkg/RcppArmadillo/inst/doc/RcppArmadillo-intro.Rnw 2013-02-28 20:14:48 UTC (rev 4274)
+++ pkg/RcppArmadillo/inst/doc/RcppArmadillo-intro.Rnw 2013-03-01 14:22:44 UTC (rev 4275)
@@ -1,54 +1,35 @@
-\documentclass[11pt]{article}
+\documentclass[preprint,authoryear,times]{elsarticle}
%\VignetteIndexEntry{RcppArmadillo-introduction}
%\VignetteKeywords{R, C++, Armadillo, linear algebra, kalman filter}
%\VignettePackage{RcppArmadillo}
-\usepackage[USletter]{vmargin}
-%\setmargrb{0.75in}{0.75in}{0.75in}{0.75in}
-\setmargrb{1in}{1in}{1in}{1in}
+\usepackage{url} % break URLs
+\usepackage{booktabs} % fancier tables
+\usepackage{color} % color use
+\usepackage{minted}
+%\usemintedstyle{bw} % enfore black/white for publication
+\newminted{r}{linenos,firstnumber=1,stepnumber=2,frame=lines,fontsize=\small}
+\newminted{cpp}{linenos,firstnumber=1,stepnumber=2,frame=lines,fontsize=\small}
+\newminted{matlab}{linenos,firstnumber=1,stepnumber=2,frame=lines,fontsize=\small}
-\usepackage{ae} % 'almost european' computer modern font
+\usepackage[colorlinks]{hyperref}% for \href
+\definecolor{link}{rgb}{0,0,0.3} % next few lines courtesy of RJournal.sty
+\hypersetup{
+ colorlinks,%
+ citecolor=link,%
+ filecolor=link,%
+ linkcolor=link,%
+ urlcolor=link
+}
-\usepackage[authoryear,round,longnamesfirst]{natbib}
-\usepackage{url} % break URLs
-\usepackage{booktabs} % fancier tables
-\usepackage{color} % color use
-\usepackage{listings} % code examples
-\definecolor{darkgray}{rgb}{0.975,0.975,0.975}
-\lstset{backgroundcolor=\color{darkgray}}
-\lstset{numbers=left, numberstyle=\tiny, stepnumber=2, numbersep=5pt}
-\lstset{keywordstyle=\color{black}\bfseries\tt}
-\lstset{ %
- %language=Octave, % the language of the code
- %basicstyle=\footnotesize, % the size of the fonts that are used for the code
- basicstyle=\small, % the size of the fonts that are used for the code
- numbers=left, % where to put the line-numbers
- %numberstyle=\footnotesize, % the size of the fonts that are used for the line-numbers
- stepnumber=2, % the step between two line-numbers. If it's 1, each line
- % will be numbered
- numbersep=5pt, % how far the line-numbers are from the code
- %backgroundcolor=\color{white}, % choose the background color. You must add \usepackage{color}
- showspaces=false, % show spaces adding particular underscores
- showstringspaces=false, % underline spaces within strings
- showtabs=false, % show tabs within strings adding particular underscores
- %frame=single, % adds a frame around the code
- tabsize=2, % sets default tabsize to 2 spaces
- captionpos=b, % sets the caption-position to bottom
- breaklines=true, % sets automatic line breaking
- breakatwhitespace=false % sets if automatic breaks should only happen at whitespace
- %title=\lstname, % show the filename of files included with \lstinputlisting;
- % also try caption instead of title
- %escapeinside={\%*}{*)}, % if you want to add a comment within your code
- %morekeywords={*,...} % if you want to add more keywords to the set
-}
%%% from jss.cls defs
\makeatletter
\newcommand\code{\bgroup\@makeother\_\@makeother\~\@makeother\$\@codex}
\def\@codex#1{{\normalfont\ttfamily\hyphenchar\font=-1 #1}\egroup}
\makeatother
-\newcommand{\proglang}[1]{\textsf{#1}}
-%\newcommand{\proglang}[1]{#1} % also neutering the proglang macro
+%\newcommand{\proglang}[1]{\textsf{#1}}
+\newcommand{\proglang}[1]{#1} % also neutering the proglang macro
\newcommand{\R}{\proglang{R}\ } % NB forces a space so not good before % fullstop etc.
\newcommand{\Rns}{\proglang{R}} % without the space
\newcommand{\Cpp}{\proglang{C++}\ }
@@ -57,6 +38,9 @@
%\newcommand{\pkg}[1]{{\it #1}}
\newcommand{\pkg}[1]{{#1}} % null op for now
+\journal{Computational Statistics and Data Analysis}
+
+
<<echo=FALSE,print=FALSE>>=
prettyVersion <- packageDescription("RcppArmadillo")$Version
prettyDate <- format(Sys.Date(), "%B %e, %Y")
@@ -64,6 +48,833 @@
\begin{document}
+\begin{frontmatter}
+
+ \title{RcppArmadillo: Accelerating R \\with High-Performance C++ Linear Algebra\footnote{
+ This vignette corresponds to a
+ \href{http://dx.doi.org/10.1016/j.csda.2013.02.005}{paper published} in
+ \href{http://www.journals.elsevier.com/computational-statistics-and-data-analysis/}{Computational Statistics and Data Analysis}.
+ Currently still identical to the paper, this vignette version may over time receive minor updates.
+ For citations, please use \citet{Eddelbuettel+Sanderson:2013:RcppArmadillo} as provided by \code{citation("RcppArmadillo")}.
+ %
+ This version corresponds to \pkg{RcppArmadillo} version \Sexpr{prettyVersion} and was
+ typeset on \Sexpr{prettyDate}.
+ }
+ }
+
+ \author[de]{Dirk Eddelbuettel}%\corref{cor}}
+ %\ead[de]{edd at debian.org}
+ % \ead[de,url]{http://dirk.eddelbuettel.com}
+ %\cortext[cor]{Corresponding author. Email: \url{edd at debian.org}.}% Postal address: 711 Monroe Avenue,
+ %River Forest, IL 60305, USA. } %he \pkg{RcppArmadillo} package is available
+ %with the electronic version of this article, as well as via every CRAN mirror.}
+ \address[de]{Debian Project, \url{http://www.debian.org}}
+
+ \author[cs1,cs2]{Conrad Sanderson}
+ %\ead[cs1]{nowhere} % CS i'd prefer to leave out my email address
+ %\ead[cs1,url]{http://www.nicta.com.au/people/sandersonc}
+ %\ead[cs2,url]{http://itee.uq.edu.au/~conrad/}
+ \address[cs1]{NICTA, PO Box 6020, St Lucia, QLD 4067, Australia}
+ \address[cs2]{Queensland University of Technology (QUT), Brisbane, QLD 4000, Australia}
+
+ \begin{abstract}
+
+ \noindent
+ The \proglang{R} statistical environment and language has demonstrated
+ particular strengths for interactive development of statistical
+ algorithms, as well as data modelling and visualisation. Its current
+ implementation has an interpreter at its core which may result in a
+ performance penalty in comparison to directly executing user algorithms
+ in the native machine code of the host CPU. In contrast, the
+ \proglang{C++} language has no built-in visualisation capabilities,
+ handling of linear algebra or even basic statistical algorithms; however,
+ user programs are converted to high-performance machine code, ahead of
+ execution.
+ %
+ A new method avoids possible speed penalties in
+ \proglang{R} by using the \pkg{Rcpp} extension package in conjunction
+ with the \pkg{Armadillo} \Cpp matrix library. In addition to the
+ inherent performance advantages of compiled code, \pkg{Armadillo}
+ provides an easy-to-use template-based meta-programming framework,
+ allowing the automatic pooling of several linear algebra operations into
+ one, which in turn can lead to further speedups.
+ With the aid of \pkg{Rcpp} and \pkg{Armadillo}, conversion of linear
+ algebra centered algorithms from \proglang{R} to \proglang{C++} becomes
+ straightforward. The algorithms retains the overall structure as
+ well as readability, all while maintaining a bidirectional link with the
+ host R environment. Empirical timing comparisons of \proglang{R} and
+ \proglang{C++} implementations of a Kalman filtering algorithm indicate a
+ speedup of several orders of magnitude.
+
+ \end{abstract}
+
+ \begin{keyword}
+ Software \sep R \sep C++ \sep linear algebra
+ \end{keyword}
+
+\end{frontmatter}
+
+
+\section{Overview}
+
+Linear algebra is a cornerstone of statistical computing and statistical
+software systems. Various matrix decompositions, linear program solvers, and
+eigenvalue / eigenvector computations are key to many estimation and analysis
+routines. As generally useful procedures, these are often abstracted and
+regrouped in specific libraries for linear algebra which statistical
+programmers have provided for various programming languages and environments.
+
+One such environment and statistical programming language is R
+\citep{R:Main}. It has become a tool of choice for data analysis and applied
+statistics \citep{Morandat_2012}. While R has particular strengths
+at fast prototyping and easy visualisation of data, its
+implementation has an interpreter at its core. In comparison to running user
+algorithms in the native machine code of the host CPU, the use of an
+interpreter often results in a performance penalty for non-trivial algorithms
+that perform elaborate data manipulation \citep{Morandat_2012}. With user
+algorithms becoming more complex and increasing in functionality, as well as
+with data sets which continue to increase in size, the issue of execution
+speed becomes more important.
+
+The \Cpp language offers a complementary set of attributes: while it has no
+built-in visualisation capabilities nor handling of linear algebra or
+statistical methods, user programs are converted to high-performance machine
+code ahead of execution. It is also inherently flexible. One key feature is
+\textit{operator overloading} which allows the programmer to define custom
+behaviour for mathematical operators such as $+$, $-$, $*$
+\citep{Meyers:2005:EffectiveC++}. \Cpp also provides language constructs
+known as {\it templates}, originally intended to easily allow the reuse of
+algorithms for various object types, and later extended to a programming
+construct in its own right called \textit{template meta-programming}
+\citep{Vandevoorde_2002,Abrahams_2004}
+
+Operator overloading allows mathematical operations to be extended to
+user-defined objects, such as matrices. This in turn allows linear algebra
+expressions to be written in a more natural manner (eg.~\mbox{$X = 0.1*A +
+ 0.2*B$}), rather than the far less readable traditional function call
+syntax, eg.~\mbox{$X = \mbox{\it add}(\mbox{\it multiply}(0.1,A), \mbox{\it
+ multiply}(0.2,B))$}.
+
+Template meta-programming is the process of inducing the \Cpp compiler to
+execute, at compile time, Turing-complete programs written in a somewhat
+opaque subset of the \Cpp language~\citep{Vandevoorde_2002,Abrahams_2004}.
+These meta-programs in effect generate further \Cpp code (often specialised
+for particular object types), which is finally converted into machine code.
+
+An early and influential example of exploiting both meta-programming and
+overloading of mathematical operators was provided by the Blitz++ library
+\citep{Veldhuizen:1998:Blitz}, targeted for efficient processing of arrays.
+Blitz++ employed elaborate meta-programming to avoid the generation of
+temporary array objects during the evaluation of mathematical expressions.
+However, the library's capabilities and usage were held back at the time by
+the limited availability of compilers correctly implementing all the
+necessary features and nuances of the \Cpp language.
+
+We present a new method of avoiding the speed penalty in R by
+using the Rcpp extension package \citep{Eddelbuettel+Francois:2011:Rcpp,
+ CRAN:Rcpp,Eddelbuettel:2013:Rcpp} in conjunction with the \pkg{Armadillo} \Cpp linear algebra
+library \citep{Sanderson:2010:Armadillo}. Similar to Blitz++,
+\pkg{Armadillo} uses operator overloading and various template
+meta-programming techniques to attain efficiency. However, it has been
+written to target modern \Cpp compilers as well as providing a much larger
+set of linear algebra operations than Blitz++. R programs augmented to use
+\pkg{Armadillo} retain the overall structure as well as readability, all
+while retaining a bidirectional link with the host R environment.
+
+Section~\ref{sec:arma} provides an overview of \pkg{Armadillo}, followed by
+its integration with the Rcpp extension package. Section~\ref{sec:kalman}
+shows an example of an R program and its conversion to \Cpp via Rcpp and
+\pkg{Armadillo}. Section~\ref{sec:speed} discusses an empirical timing
+comparison between the R and \Cpp versions before
+Section~\ref{sec:conclusion} concludes.
+
+
+\section{Armadillo}
+\label{sec:arma}
+
+The \pkg{Armadillo} \Cpp library provides vector, matrix and cube types
+(supporting integer, floating point and complex numbers) as well as a subset
+of trigonometric and statistics functions~\citep{Sanderson:2010:Armadillo}.
+In addition to elementary operations such as addition and matrix
+multiplication, various matrix factorisations and submatrix manipulation
+operations are provided. The corresponding application programming interface
+(syntax) enables the programmer to write code which is both concise and
+easy-to-read to those familiar with scripting languages such as
+\proglang{Matlab} and \proglang{R}. Table~\ref{tab:arma} lists a few common
+\pkg{Armadillo} functions.
+
+Matrix multiplication and factorisations are accomplished through integration
+with the underlying operations stemming from standard numerical libraries
+such as BLAS and LAPACK~\citep{Demmel_1997}. Similar to how environments
+such as R are implemented, these underlying libraries can be replaced in a
+transparent manner with variants that are optimised to the specific hardware
+platform and/or multi-threaded to automatically take advantage of the
+now-common multi-core platforms~\citep{Kurzak_2010}.
+
+\begin{table}[!b]
+ \centering
+ \footnotesize
+ \begin{tabular}{ll}
+ \toprule
+ \textbf{Armadillo function} \phantom{XXXXXXX} & \textbf{Description} \\
+ \midrule
+ \code{X(1,2) = 3} & Assign value 3 to element at location (1,2) of matrix $X$ \\ % DE shortened to fit on \textwidth
+ \code{X = A + B} & Add matrices $A$ and $B$ \\
+ \code{X( span(1,2), span(3,4) )} & Provide read/write access to submatrix of $X$ \\
+ \code{zeros(rows [, cols [, slices]))} & Generate vector (or matrix or cube) of zeros\\
+ \code{ones(rows [, cols [, slices]))} & Generate vector (or matrix or cube) of ones\\
+ \code{eye(rows, cols)} & Matrix diagonal set to 1, off-diagonal elements set to 0 \\
+ %\code{linspace(start, end, N=100)} & $N$ element vector with elements from start to end \\
+ \code{repmat(X, row_copies, col_copies)} & Replicate matrix $X$ in block-like manner \\
+ \code{det(X)} & Returns the determinant of matrix $X$\\
+ %\code{dot(A, B)} & Dot-product of confirming vectors $A$ and $B$ \\
+ \code{norm(X, p)} & Compute the $p$-norm of matrix or vector $X$\\
+ \code{rank(X)} & Compute the rank of matrix $X$ \\
+ %\code{trace(X)} & Compute the trace of matrix $X$ \\
+ %\code{diagvec(X, k=0)} & Extracts the $k$-th diagnonal from matrix $X$\\
+ \code{min(X, dim=0)};~ \code{max(X, dim=0)} & Extremum value of each column~of $X$~(row if \code{dim=1}) \\
+ \code{trans(X)} ~or~ \code{X.t()} & Return transpose of $X$ \\
+ \code{R = chol(X)} & Cholesky decomposition of $X$ such that $R^{T} R = X$ \\
+ \code{inv(X)} ~or~ \code{X.i()} & Returns the inverse of square matrix $X$ \\
+ \code{pinv(X)} & Returns the pseudo-inverse of matrix $X$ \\
+ \code{lu(L, U, P, X)} & LU decomp.~with partial pivoting; also \code{lu(L, U, X)} \\
+ %\code{lu(L, U, P, X)} & LU decomposition with partial pivoting \\
+ \code{qr(Q, R, X)} & QR decomp.~into orthogonal $Q$ and right-triangular $R$\\
+ \code{X = solve(A, B)} & Solve system $AX = B$ for $X$ \\
+ \code{s = svd(X); svd(U, s, V, X)} & Singular-value decomposition of $X$ \\
+ \bottomrule
+ \end{tabular}
+\caption{Selected \pkg{Armadillo} functions with brief descriptions; see
+ \texttt{http://arma.sf.net/docs.html} for more complete
+ documentation. Several optional additional arguments have been omitted
+ here for brevity.\label{tab:arma}}
+\end{table}
+
+\pkg{Armadillo} uses a delayed evaluation approach to combine several
+operations into one and reduce (or eliminate) the need for temporary objects.
+In contrast to brute-force evaluations, delayed evaluation can provide
+considerable performance improvements as well as reduced memory usage.
+The delayed evaluation machinery is accomplished through template
+meta-programming~\citep{Vandevoorde_2002,Abrahams_2004}, where the \Cpp
+compiler is induced to reason about mathematical expressions at {\it compile
+ time}. Where possible, the \Cpp compiler can generate machine code that is
+tailored for each expression.
+
+As an example of the possible efficiency gains, let us consider the
+expression \mbox{$X = A - B + C$}, where $A$, $B$ and $C$ are matrices. A
+brute-force implementation would evaluate $A-B$ first and store the result in
+a temporary matrix $T$. The next operation would be \mbox{$T + C$}, with the
+result finally stored in $X$. The creation of the temporary matrix, and
+using two separate loops for the subtraction and addition of matrix elements
+is suboptimal from an efficiency point of view.
+
+Through the overloading of mathematical operators, \pkg{Armadillo} avoids the
+generation of the temporary matrix by first converting the expression into a
+set of lightweight \code{Glue} objects, which only store references to the
+matrices and \pkg{Armadillo}'s representations of mathematical expressions
+(eg.~other \code{Glue} objects). To indicate that an operation comprised of
+subtraction and addition is required, the exact type of the \code{Glue}
+objects is automatically inferred from the given expression through template
+meta-programming. More specifically, given the expression \mbox{$X = A - B +
+ C$}, \pkg{Armadillo} automatically induces the compiler to generate an
+instance of the lightweight \code{Glue} storage object with the following
+\Cpp {\it type}:
+
+\centerline{~}
+\centerline{\code{Glue< Glue<Mat, Mat, glue\_minus>, Mat, glue\_plus>}}
+\centerline{~}
+
+\noindent
+where \code{Glue<...>} indicates that \code{Glue} is a C++ template class,
+with the items between `\code{<}' and `\code{>}' specifying template
+parameters; the outer \code{Glue<..., Mat, glue\_plus>} is the \code{Glue}
+object indicating an addition operation, storing a reference to a matrix as
+well as a reference to another \code{Glue} object; the inner \code{Glue<Mat,
+ Mat, glue\_minus>} stores references to two matrices and indicates a
+subtraction operation. In both the inner and outer \code{Glue}, the type
+\code{Mat} specifies that a reference to a matrix object is to be held.
+
+The expression evaluator in \pkg{Armadillo} is then automatically invoked
+through the ``\code{=}'' operation, which interprets (at compile time) the
+template parameters of the compound \code{Glue} object and generates \Cpp
+code equivalent to:
+
+\centerline{~}
+\centerline{\code{for(int i=0; i<N; i++) \{ X[i] = (A[i] - B[i]) + C[i]; \}}}
+\centerline{~}
+
+\noindent
+where $N$ is the number of elements in $A$, $B$ and $C$, with \code{A[i]}
+indicating the $i$-th element in $A$. As such, apart from the lightweight
+\code{Glue} objects (for which memory is pre-allocated at compile time), no
+other temporary object is generated, and only one loop is required instead of
+two. Given a sufficiently advanced \Cpp compiler, the lightweight
+\code{Glue} objects can be optimised away, as they are automatically
+generated by the compiler and only contain compile-time generated references;
+the resultant machine code can appear as if the \code{Glue} objects never
+existed in the first place.
+
+Note that due to the ability of the \code{Glue} object to hold references to
+other \code{Glue} objects, far longer and more complicated operations can be
+easily accommodated. Further discussion of template meta-programming is
+beyond the scope of this paper; for more details, the interested reader is
+referred to~\cite{Vandevoorde_2002} as well as~\cite{Abrahams_2004}.
+\citet{Reddy_2013} provide a recent application of \proglang{Armadillo}
+in computer vision and pattern recognition.
+
+\section{RcppArmadillo}
+\label{sec:rcpparma}
+
+The \pkg{RcppArmadillo} package \citep{CRAN:RcppArmadillo} employs the Rcpp
+package \citep{Eddelbuettel+Francois:2011:Rcpp,CRAN:Rcpp,Eddelbuettel:2013:Rcpp} to provide a
+bidirectional interface between \R and \Cpp at the object level. Using
+templates, \R objects such as vectors and matrices can be mapped directly to
+the corresponding \pkg{Armadillo} objects.
+
+\begin{listing}[b!]
+\caption{Integrating \pkg{Armadillo}-based C++ code via the
+ \mbox{RcppArmadillo} package.\label{code:RcppArmaEx}
+}
+\begin{rcode}
+R> library(inline)
+R>
+R> g <- cxxfunction(signature(vs="numeric"),
++ plugin="RcppArmadillo", body='
++ arma::vec v = Rcpp::as<arma::vec>(vs);
++ arma::mat op = v * v.t();
++ double ip = arma::as_scalar(v.t() * v);
++ return Rcpp::List::create(Rcpp::Named("outer")=op,
++ Rcpp::Named("inner")=ip);
++')
+R> g(7:11)
+$outer
+ [,1] [,2] [,3] [,4] [,5]
+[1,] 49 56 63 70 77
+[2,] 56 64 72 80 88
+[3,] 63 72 81 90 99
+[4,] 70 80 90 100 110
+[5,] 77 88 99 110 121
+
+$inner
+[1] 415
+\end{rcode}
+\end{listing}
+
+Consider the simple example in Listing~\ref{code:RcppArmaEx}. Given a
+vector, the \code{g()} function returns both the outer and inner products.
+We load the inline package \citep{CRAN:inline}, which provides
+\code{cxxfunction()} that we use to compile, link and load the \Cpp code
+which is passed as the \code{body} argument. We declare the function
+signature to contain a single argument named `\code{vs}'. On line five, this
+argument is used to instantiate an \pkg{Armadillo} column vector object named
+`\code{v}' (using the templated conversion function \code{as()} from Rcpp).
+In lines six and seven, the outer and inner product of the column vector
+are calculated by appropriately multiplying the vector with its transpose.
+This shows how the \code{*} operator for multiplication has been overloaded
+to provide the appropriate operation for the types implemented by
+\pkg{Armadillo}. The inner product creates a scalar variable, and in
+contrast to \R where each object is a vector type (even if of length one), we
+have to explicitly convert using \code{as_scalar()} to assign the value to a
+variable of type \code{double}.
+
+
+Finally, the last line creates an \R named list type containing both results.
+As a result of calling \code{cxxfunction()}, a new function is created. It
+contains a reference to the native code, compiled on the fly based on the
+\Cpp code provided to \code{cxxfunction()} and makes it available directly
+from \R under a user-assigned function name, here \code{g()}. The listing
+also shows how the \code{Rcpp} and \code{arma} namespaces are used to
+disambiguate symbols from the two libraries; the \code{::} operator is
+already familiar to R programmers who use the NAMESPACE directive in \R in a
+similar fashion.
+
+The listing also demonstrates how the new function \code{g()} can be called
+with a suitable argument. Here we create a vector of five elements,
+containing values ranging from 7 to 11. The function's output, here the list
+containing both outer and inner product, is then displayed as it is not
+assigned to a variable.
+
+This simple example illustrates how \R objects can be transferred directly
+into corresponding \pkg{Armadillo} objects using the interface code provided
+by \pkg{Rcpp}. It also shows how deployment of \pkg{RcppArmadillo} is
+straightforward, even for interactive work where functions can be compiled on
+the fly. Similarly, usage in packages is also uncomplicated and follows the
+documentation provided with \pkg{Rcpp}~\citep{CRAN:Rcpp,Eddelbuettel:2013:Rcpp}.
+
+
+\section{Kalman Filtering Example}
+\label{sec:kalman}
+
+The Kalman filter is ubiquitous in many engineering disciplines as well as in
+statistics and econometrics~\citep{Tusell:2010:Kalman}. A recent example of an
+application is volatility extraction in a diffusion option pricing model~\citep{Li_CSDA_2013}.
+Even in its simplest linear form, the Kalman filter can provide simple estimates
+by recursively applying linear updates which are robust to noise and can cope
+with missing data. Moreover, the estimation process is lightweight and fast,
+and consumes only minimal amounts of memory as few state variables are required.
+%
+We discuss a standard example below. The (two-dimensional) position of an
+object is estimated based on past values. A $6 \times 1$ state vector
+includes $X$ and $Y$ coordinates determining the position, two variables for
+speed (or velocity) $V_X$ and $V_Y$ relative to the two coordinates, as well
+as two acceleration variables $A_X$ and $A_Y$.
+
+We have the positions being updated as a function of the velocity
+
+\begin{displaymath}
+ X = X_0 + V_X dt
+ \mbox{\phantom{XX} and \phantom{XX}}
+ Y = Y_0 + V_Y dt,
+\end{displaymath}
+
+\noindent
+and the velocity being updated as a function of the (unobserved) acceleration:
+
+\begin{displaymath}
+ V_x = V_{X,0} + A_X dt
+ \mbox{\phantom{XX} and \phantom{XX}}
+ V_y = V_{Y,0} + A_Y dt.
+\end{displaymath}
+
+% \begin{eqnarray*}
+% X & = & X_0 + V_x dt \\
+% Y & = & Y_0 + V_y dt \\
+% V_x & = & V_{x,0} + A_x dt \\
+% V_y & = & V_{y,0} + A_y dt \\
+% \end{eqnarray*}
+
+With covariance matrices $Q$ and $R$ for (Gaussian) error terms, the standard
+Kalman filter estimation involves a linear prediction step resulting in a new
+predicted state vector, and a new covariance estimate. This leads to a
+residuals vector and a covariance matrix for residuals which are used to
+determine the (optimal) Kalman gain, which is then used to update the state
+estimate and covariance matrix.
+
+All of these steps involve only matrix multiplication and inversions, making
+the algorithm very suitable for an implementation in any language which
+can use matrix expressions. An example for \proglang{Matlab} is provided on
+the Mathworks website\footnote{See
+ \url{http://www.mathworks.com/products/matlab-coder/demos.html?file=/products/demos/shipping/coder/coderdemo_kalman_filter.html}.}
+and shown in Listing~\ref{code:matlabkalman}.
+
+\begin{listing}[t!]
+\caption{Basic Kalman Filter in \proglang{Matlab}.\label{code:matlabkalman}}
+\begin{matlabcode}
+% Copyright 2010 The MathWorks, Inc.
+function y = kalmanfilter(z)
+ dt=1;
+ % Initialize state transition matrix
+ A=[ 1 0 dt 0 0 0; 0 1 0 dt 0 0;... % [x ], [y ]
[TRUNCATED]
To get the complete diff run:
svnlook diff /svnroot/rcpp -r 4275
More information about the Rcpp-commits
mailing list